diff --git a/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/scm/protocol/StorageContainerLocationInternalInterface.java b/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/scm/protocol/StorageContainerLocationInternalInterface.java new file mode 100644 index 000000000000..51cb9d92690f --- /dev/null +++ b/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/scm/protocol/StorageContainerLocationInternalInterface.java @@ -0,0 +1,545 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF 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. + */ + +package org.apache.hadoop.hdds.scm.protocol; + +import jakarta.annotation.Nullable; +import java.io.Closeable; +import java.io.IOException; +import java.util.Collections; +import java.util.EnumSet; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.Set; +import java.util.UUID; +import org.apache.hadoop.hdds.client.ReplicationConfig; +import org.apache.hadoop.hdds.protocol.DatanodeDetails; +import org.apache.hadoop.hdds.protocol.proto.HddsProtos; +import org.apache.hadoop.hdds.protocol.proto.HddsProtos.DeletedBlocksTransactionInfo; +import org.apache.hadoop.hdds.protocol.proto.HddsProtos.DeletedBlocksTransactionSummary; +import org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.ContainerBalancerStatusInfoResponseProto; +import org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.DecommissionScmResponseProto; +import org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.SafeModeRuleStatusProto; +import org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.StartContainerBalancerResponseProto; +import org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.Type; +import org.apache.hadoop.hdds.scm.DatanodeAdminError; +import org.apache.hadoop.hdds.scm.ScmInfo; +import org.apache.hadoop.hdds.scm.container.ContainerID; +import org.apache.hadoop.hdds.scm.container.ContainerInfo; +import org.apache.hadoop.hdds.scm.container.ContainerListResult; +import org.apache.hadoop.hdds.scm.container.ReplicationManagerReport; +import org.apache.hadoop.hdds.scm.container.common.helpers.ContainerWithPipeline; +import org.apache.hadoop.hdds.scm.pipeline.Pipeline; +import org.apache.hadoop.ozone.upgrade.UpgradeFinalization.StatusAndMessages; +import org.apache.hadoop.security.token.Token; + +/** + * Internal Java interface for the StorageContainerLocationProtocolService RPC + * protocol. + */ +public interface StorageContainerLocationInternalInterface extends Closeable { + + /** + * Admin command should take effect on all SCM instance. + */ + Set ADMIN_COMMAND_TYPE = Collections.unmodifiableSet(EnumSet.of( + Type.StartReplicationManager, + Type.StopReplicationManager, + Type.ForceExitSafeMode)); + + /** + * Read-only commands that can execute on followers without leader check. + * These commands respect the --scm parameter and query the specified SCM. + */ + Set FOLLOWER_READABLE_COMMAND_TYPES = Collections.unmodifiableSet(EnumSet.of( + Type.InSafeMode, + Type.GetSafeModeRuleStatuses)); + + /** + * Asks SCM where a container should be allocated. SCM responds with the + * set of datanodes that should be used creating this container. + * + */ + ContainerWithPipeline allocateContainer( + HddsProtos.ReplicationType replicationType, + HddsProtos.ReplicationFactor factor, String owner) + throws IOException; + + ContainerWithPipeline allocateContainer(ReplicationConfig replicationConfig, String owner) throws IOException; + + /** + * Ask SCM the location of the container. SCM responds with a group of + * nodes where this container and its replicas are located. + * + * @param containerID - ID of the container. + * @return ContainerInfo - the container info such as where the pipeline + * is located. + * @throws IOException + */ + ContainerInfo getContainer(long containerID) throws IOException; + + /** + * Ask SCM the location of the container. SCM responds with a group of + * nodes where this container and its replicas are located. + * + * @param containerID - ID of the container. + * @return ContainerWithPipeline - the container info with the pipeline. + * @throws IOException + */ + ContainerWithPipeline getContainerWithPipeline(long containerID) + throws IOException; + + /** + * Gets the list of ReplicaInfo known by SCM for a given container. + * @param containerId ID of the container + * @return List of ReplicaInfo for the container or an empty list if none. + * @throws IOException + */ + List getContainerReplicas( + long containerId, int clientVersion) throws IOException; + + /** + * Ask SCM the location of a batch of containers. SCM responds with a group of + * nodes where these containers and their replicas are located. + * + * @param containerIDs - IDs of a batch of containers. + * @return List of ContainerWithPipeline + * - the container info with the pipeline. + * @throws IOException + */ + List getContainerWithPipelineBatch( + Iterable containerIDs) throws IOException; + + /** + * Ask SCM which containers of the given list exist. + * + * @param containerIDs - IDs of a batch of containers. + * @return List of ContainerWithPipeline that exist in SCM + * - the container info with the pipeline. + */ + List getExistContainerWithPipelinesInBatch( + List containerIDs); + + /** + * Ask SCM a list of containers with a range of container names + * and the limit of count. + * Search container names between start name(exclusive), and + * use prefix name to filter the result. the max size of the + * searching range cannot exceed the value of count. + * + * @param startContainerID start container ID. + * @param count count, if count {@literal <} 0, the max size is unlimited.( + * Usually the count will be replace with a very big + * value instead of being unlimited in case the db is very big) + * + * @return a list of containers capped by max count allowed + * in "ozone.scm.container.list.max.count" and total number of containers. + * @throws IOException + */ + ContainerListResult listContainer(long startContainerID, + int count) throws IOException; + + /** + * Ask SCM a list of containers with a range of container names + * and the limit of count. + * Search container names between start name(exclusive), and + * use prefix name to filter the result. the max size of the + * searching range cannot exceed the value of count. + * + * @param startContainerID start container ID. + * @param count count, if count {@literal <} 0, the max size is unlimited.( + * Usually the count will be replace with a very big + * value instead of being unlimited in case the db is very big) + * @param state Container with this state will be returned. + * + * @return a list of containers capped by max count allowed + * in "ozone.scm.container.list.max.count" and total number of containers. + * @throws IOException + */ + ContainerListResult listContainer(long startContainerID, + int count, HddsProtos.LifeCycleState state) throws IOException; + + /** + * Ask SCM a list of containers with a range of container names + * and the limit of count. + * Search container names between start name(exclusive), and + * use prefix name to filter the result. the max size of the + * searching range cannot exceed the value of count. + * + * @param startContainerID start container ID. + * @param count count, if count {@literal <} 0, the max size is unlimited.( + * Usually the count will be replace with a very big + * value instead of being unlimited in case the db is very big) + * @param state Container with this state will be returned. + * @param factor Container factor + * @return a list of containers capped by max count allowed + * in "ozone.scm.container.list.max.count" and total number of containers. + * @throws IOException + */ + ContainerListResult listContainer(long startContainerID, + int count, HddsProtos.LifeCycleState state, + HddsProtos.ReplicationFactor factor) throws IOException; + + /** + * Ask SCM for a list of containers with a range of container ID, state + * and replication config, and the limit of count. + * The containers are returned from startID (exclusive), and + * filtered by state and replication config. The returned list is limited to + * count entries. + * + * @param startContainerID start container ID. + * @param count count, if count {@literal <} 0, the max size is unlimited.( + * Usually the count will be replace with a very big + * value instead of being unlimited in case the db is very big) + * @param state Container with this state will be returned. + * @param replicationConfig Replication config for the containers + * @return a list of containers capped by max count allowed + * in "ozone.scm.container.list.max.count" and total number of containers. + * @throws IOException + */ + ContainerListResult listContainer(long startContainerID, + int count, HddsProtos.LifeCycleState state, + HddsProtos.ReplicationType replicationType, + ReplicationConfig replicationConfig) throws IOException; + + /** + * Ask SCM for a list of containers with a range of container ID, state + * and replication config, and the limit of count. + * The containers are returned from startID (exclusive), and + * filtered by state and replication config. The returned list is limited to + * count entries. + * + * @param startContainerID start container ID. + * @param count count, if count {@literal <} 0, the max size is unlimited.( + * Usually the count will be replace with a very big + * value instead of being unlimited in case the db is very big) + * @param state Container with this state will be returned. + * @param replicationConfig Replication config for the containers + * @param suppressed container to be suppressed/unsuppressed from report + * @return a list of containers capped by max count allowed + * in "ozone.scm.container.list.max.count" and total number of containers. + * @throws IOException + */ + ContainerListResult listContainer(long startContainerID, + int count, HddsProtos.LifeCycleState state, + HddsProtos.ReplicationType replicationType, + ReplicationConfig replicationConfig, + Boolean suppressed) throws IOException; + + /** + * Deletes a container in SCM. + * + * @param containerID + * @throws IOException + * if failed to delete the container mapping from db store + * or container doesn't exist. + */ + void deleteContainer(long containerID) throws IOException; + + /** + * Gets the list of underReplicated and unClosed containers on a decommissioning node. + * + * @param dn - Datanode detail + * @return Lists of underReplicated and unClosed containers + */ + Map> getContainersOnDecomNode(DatanodeDetails dn) throws IOException; + + /** + * Queries a list of Node Statuses. Passing a null for either opState or + * state acts like a wildcard returning all nodes in that state. + * @param opState The node operational state + * @param state The node health + * @param clientVersion Client's version number + * @return List of Datanodes. + * @see org.apache.hadoop.ozone.ClientVersion + */ + List queryNode(HddsProtos.NodeOperationalState opState, + HddsProtos.NodeState state, HddsProtos.QueryScope queryScope, + String poolName, int clientVersion) throws IOException; + + HddsProtos.Node queryNode(UUID uuid) throws IOException; + + List decommissionNodes(List nodes, boolean force) + throws IOException; + + List recommissionNodes(List nodes) + throws IOException; + + List startMaintenanceNodes(List nodes, + int endInHours, boolean force) throws IOException; + + /** + * Close a container. + * + * @param containerID ID of the container to close + * @throws IOException in case of any Exception + */ + void closeContainer(long containerID) throws IOException; + + /** + * Creates a replication pipeline of a specified type. + * @param type - replication type + * @param factor - factor 1 or 3 + * @param nodePool - optional machine list to build a pipeline. + * @throws IOException + */ + Pipeline createReplicationPipeline(HddsProtos.ReplicationType type, + HddsProtos.ReplicationFactor factor, HddsProtos.NodePool nodePool) + throws IOException; + + /** + * Returns the list of active Pipelines. + * + * @return list of Pipeline + * + * @throws IOException in case of any exception + */ + List listPipelines() throws IOException; + + /** + * Returns Pipeline with given ID if present. + * + * @return Pipeline + * + * @throws IOException in case of any exception + */ + Pipeline getPipeline(HddsProtos.PipelineID pipelineID) throws IOException; + + /** + * Activates a dormant pipeline. + * + * @param pipelineID ID of the pipeline to activate. + * @throws IOException in case of any Exception + */ + void activatePipeline(HddsProtos.PipelineID pipelineID) throws IOException; + + /** + * Deactivates an active pipeline. + * + * @param pipelineID ID of the pipeline to deactivate. + * @throws IOException in case of any Exception + */ + void deactivatePipeline(HddsProtos.PipelineID pipelineID) throws IOException; + + /** + * Closes a pipeline given the pipelineID. + * + * @param pipelineID ID of the pipeline to demolish + * @throws IOException + */ + void closePipeline(HddsProtos.PipelineID pipelineID) throws IOException; + + /** + * Returns information about SCM. + * + * @return {@link ScmInfo} + * @throws IOException + */ + ScmInfo getScmInfo() throws IOException; + + /** + * Transfer the raft leadership. + * + * @param newLeaderId the newLeaderId of the target expected leader + * @throws IOException + */ + void transferLeadership(String newLeaderId) throws IOException; + + /** + * Return the failed transactions of the Deleted blocks. A transaction is + * considered to be failed if it has been sent more than MAX_RETRY limit + * and its count is reset to -1. + * + * @param count Maximum num of returned transactions, if {@literal < 0}. return all. + * @param startTxId The least transaction id to start with. + * @return a list of failed deleted block transactions. + * @throws IOException + */ + @Deprecated + List getFailedDeletedBlockTxn(int count, + long startTxId) throws IOException; + + /** + * Reset the failed deleted block retry count. + * + * @param txIDs transactionId list to be reset + * @return num of successful reset + * @throws IOException + */ + @Deprecated + int resetDeletedBlockRetryCount(List txIDs) throws IOException; + + + /** + * Get deleted block summary. + * @throws IOException + */ + @Nullable + DeletedBlocksTransactionSummary getDeletedBlockSummary() throws IOException; + + /** + * Check if SCM is in safe mode. + * + * @return Returns true if SCM is in safe mode else returns false. + * @throws IOException + */ + boolean inSafeMode() throws IOException; + + List getSafeModeRuleStatuses() throws IOException; + + /** + * Force SCM out of Safe mode. + * + * @return returns true if operation is successful. + * @throws IOException + */ + boolean forceExitSafeMode() throws IOException; + + /** + * Start ReplicationManager. + */ + void startReplicationManager() throws IOException; + + /** + * Stop ReplicationManager. + */ + void stopReplicationManager() throws IOException; + + /** + * Returns ReplicationManager status. + * + * @return True if ReplicationManager is running, false otherwise. + */ + boolean getReplicationManagerStatus() throws IOException; + + /** + * Returns the latest container summary report generated by Replication + * Manager. + * @return The latest ReplicationManagerReport. + * @throws IOException + */ + ReplicationManagerReport getReplicationManagerReport() throws IOException; + + /** + * Start ContainerBalancer. + * @return {@link StartContainerBalancerResponseProto} that contains the + * start status and an optional message. + */ + @SuppressWarnings("checkstyle:parameternumber") + StartContainerBalancerResponseProto startContainerBalancer( + Optional threshold, + Optional iterations, + Optional maxDatanodesPercentageToInvolvePerIteration, + Optional maxSizeToMovePerIterationInGB, + Optional maxSizeEnteringTargetInGB, + Optional maxSizeLeavingSourceInGB, + Optional balancingInterval, + Optional moveTimeout, + Optional moveReplicationTimeout, + Optional networkTopologyEnable, + Optional includeNodes, + Optional excludeNodes, + Optional excludeContainers, + Optional includeContainers) throws IOException; + + /** + * Stop ContainerBalancer. + */ + void stopContainerBalancer() throws IOException; + + /** + * Returns ContainerBalancer status. + * + * @return True if ContainerBalancer is running, false otherwise. + */ + boolean getContainerBalancerStatus() throws IOException; + + ContainerBalancerStatusInfoResponseProto getContainerBalancerStatusInfo() throws IOException; + + /** + * Get Datanode usage information by ip or hostname or uuid. + * + * @param address datanode IP address or Hostname String + * @param uuid datanode UUID String + * @param clientVersion Client's version number + * @return List of DatanodeUsageInfoProto. Each element contains info such as + * capacity, SCMused, and remaining space. + * @throws IOException + * @see org.apache.hadoop.ozone.ClientVersion + */ + List getDatanodeUsageInfo( + String address, String uuid, int clientVersion) throws IOException; + + /** + * Get usage information of most or least used datanodes. + * + * @param mostUsed true if most used, false if least used + * @param count Integer number of nodes to get info for + * @param clientVersion Client's version number + * @return List of DatanodeUsageInfoProto. Each element contains info such as + * capacity, SCMUsed, and remaining space. + * @throws IOException + * @see org.apache.hadoop.ozone.ClientVersion + */ + List getDatanodeUsageInfo( + boolean mostUsed, int count, int clientVersion) throws IOException; + + StatusAndMessages finalizeScmUpgrade(String upgradeClientID) + throws IOException; + + StatusAndMessages queryUpgradeFinalizationProgress( + String upgradeClientID, boolean force, boolean readonly) + throws IOException; + + /** + * Obtain a token which can be used to let datanodes verify authentication of + * commands operating on {@code containerID}. + */ + Token getContainerToken(ContainerID containerID) throws IOException; + + long getContainerCount() throws IOException; + + long getContainerCount(HddsProtos.LifeCycleState state) + throws IOException; + + List getListOfContainerIDs( + ContainerID startContainerID, int count, HddsProtos.LifeCycleState state) + throws IOException; + + DecommissionScmResponseProto decommissionScm( + String scmId) throws IOException; + + String getMetrics(String query) throws IOException; + + /** + * Trigger a reconcile command to datanodes for the current container ID. + * + * @param containerID The ID of the container to reconcile. + * @throws IOException On error + */ + void reconcileContainer(long containerID) throws IOException; + + /** + * Suppress or unsuppress containers from reports. + * + * @param containerIds container IDs to suppress or unsuppress + * @param suppress true to suppress, false to unsuppress + * @throws IOException + */ + List suppressContainers(List containerIds, boolean suppress) throws IOException; +} diff --git a/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/scm/protocol/StorageContainerLocationProtocol.java b/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/scm/protocol/StorageContainerLocationProtocol.java index 70b758ef1c44..1d71413cd984 100644 --- a/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/scm/protocol/StorageContainerLocationProtocol.java +++ b/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/scm/protocol/StorageContainerLocationProtocol.java @@ -17,529 +17,10 @@ package org.apache.hadoop.hdds.scm.protocol; -import jakarta.annotation.Nullable; -import java.io.Closeable; -import java.io.IOException; -import java.util.Collections; -import java.util.EnumSet; -import java.util.List; -import java.util.Map; -import java.util.Optional; -import java.util.Set; -import java.util.UUID; -import org.apache.hadoop.hdds.client.ReplicationConfig; -import org.apache.hadoop.hdds.protocol.DatanodeDetails; -import org.apache.hadoop.hdds.protocol.proto.HddsProtos; -import org.apache.hadoop.hdds.protocol.proto.HddsProtos.DeletedBlocksTransactionInfo; -import org.apache.hadoop.hdds.protocol.proto.HddsProtos.DeletedBlocksTransactionSummary; -import org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.ContainerBalancerStatusInfoResponseProto; -import org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.DecommissionScmResponseProto; -import org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.SafeModeRuleStatusProto; -import org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.StartContainerBalancerResponseProto; -import org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.Type; -import org.apache.hadoop.hdds.scm.DatanodeAdminError; -import org.apache.hadoop.hdds.scm.ScmInfo; -import org.apache.hadoop.hdds.scm.container.ContainerID; -import org.apache.hadoop.hdds.scm.container.ContainerInfo; -import org.apache.hadoop.hdds.scm.container.ContainerListResult; -import org.apache.hadoop.hdds.scm.container.ReplicationManagerReport; -import org.apache.hadoop.hdds.scm.container.common.helpers.ContainerWithPipeline; -import org.apache.hadoop.hdds.scm.pipeline.Pipeline; -import org.apache.hadoop.ozone.upgrade.UpgradeFinalization.StatusAndMessages; -import org.apache.hadoop.security.token.Token; - /** - * ContainerLocationProtocol is used by an HDFS node to find the set of nodes - * that currently host a container. + * An empty protocol class to preserve the RPC protocol identity while the + * internal Java interface is {@link StorageContainerLocationInternalInterface}. */ -public interface StorageContainerLocationProtocol extends Closeable { - - /** - * Admin command should take effect on all SCM instance. - */ - Set ADMIN_COMMAND_TYPE = Collections.unmodifiableSet(EnumSet.of( - Type.StartReplicationManager, - Type.StopReplicationManager, - Type.ForceExitSafeMode)); - - /** - * Read-only commands that can execute on followers without leader check. - * These commands respect the --scm parameter and query the specified SCM. - */ - Set FOLLOWER_READABLE_COMMAND_TYPES = Collections.unmodifiableSet(EnumSet.of( - Type.InSafeMode, - Type.GetSafeModeRuleStatuses)); - - /** - * Asks SCM where a container should be allocated. SCM responds with the - * set of datanodes that should be used creating this container. - * - */ - ContainerWithPipeline allocateContainer( - HddsProtos.ReplicationType replicationType, - HddsProtos.ReplicationFactor factor, String owner) - throws IOException; - - ContainerWithPipeline allocateContainer(ReplicationConfig replicationConfig, String owner) throws IOException; - - /** - * Ask SCM the location of the container. SCM responds with a group of - * nodes where this container and its replicas are located. - * - * @param containerID - ID of the container. - * @return ContainerInfo - the container info such as where the pipeline - * is located. - * @throws IOException - */ - ContainerInfo getContainer(long containerID) throws IOException; - - /** - * Ask SCM the location of the container. SCM responds with a group of - * nodes where this container and its replicas are located. - * - * @param containerID - ID of the container. - * @return ContainerWithPipeline - the container info with the pipeline. - * @throws IOException - */ - ContainerWithPipeline getContainerWithPipeline(long containerID) - throws IOException; - - /** - * Gets the list of ReplicaInfo known by SCM for a given container. - * @param containerId ID of the container - * @return List of ReplicaInfo for the container or an empty list if none. - * @throws IOException - */ - List getContainerReplicas( - long containerId, int clientVersion) throws IOException; - - /** - * Ask SCM the location of a batch of containers. SCM responds with a group of - * nodes where these containers and their replicas are located. - * - * @param containerIDs - IDs of a batch of containers. - * @return List of ContainerWithPipeline - * - the container info with the pipeline. - * @throws IOException - */ - List getContainerWithPipelineBatch( - Iterable containerIDs) throws IOException; - - /** - * Ask SCM which containers of the given list exist. - * - * @param containerIDs - IDs of a batch of containers. - * @return List of ContainerWithPipeline that exist in SCM - * - the container info with the pipeline. - */ - List getExistContainerWithPipelinesInBatch( - List containerIDs); - - /** - * Ask SCM a list of containers with a range of container names - * and the limit of count. - * Search container names between start name(exclusive), and - * use prefix name to filter the result. the max size of the - * searching range cannot exceed the value of count. - * - * @param startContainerID start container ID. - * @param count count, if count {@literal <} 0, the max size is unlimited.( - * Usually the count will be replace with a very big - * value instead of being unlimited in case the db is very big) - * - * @return a list of containers capped by max count allowed - * in "ozone.scm.container.list.max.count" and total number of containers. - * @throws IOException - */ - ContainerListResult listContainer(long startContainerID, - int count) throws IOException; - - /** - * Ask SCM a list of containers with a range of container names - * and the limit of count. - * Search container names between start name(exclusive), and - * use prefix name to filter the result. the max size of the - * searching range cannot exceed the value of count. - * - * @param startContainerID start container ID. - * @param count count, if count {@literal <} 0, the max size is unlimited.( - * Usually the count will be replace with a very big - * value instead of being unlimited in case the db is very big) - * @param state Container with this state will be returned. - * - * @return a list of containers capped by max count allowed - * in "ozone.scm.container.list.max.count" and total number of containers. - * @throws IOException - */ - ContainerListResult listContainer(long startContainerID, - int count, HddsProtos.LifeCycleState state) throws IOException; - - /** - * Ask SCM a list of containers with a range of container names - * and the limit of count. - * Search container names between start name(exclusive), and - * use prefix name to filter the result. the max size of the - * searching range cannot exceed the value of count. - * - * @param startContainerID start container ID. - * @param count count, if count {@literal <} 0, the max size is unlimited.( - * Usually the count will be replace with a very big - * value instead of being unlimited in case the db is very big) - * @param state Container with this state will be returned. - * @param factor Container factor - * @return a list of containers capped by max count allowed - * in "ozone.scm.container.list.max.count" and total number of containers. - * @throws IOException - */ - ContainerListResult listContainer(long startContainerID, - int count, HddsProtos.LifeCycleState state, - HddsProtos.ReplicationFactor factor) throws IOException; - - /** - * Ask SCM for a list of containers with a range of container ID, state - * and replication config, and the limit of count. - * The containers are returned from startID (exclusive), and - * filtered by state and replication config. The returned list is limited to - * count entries. - * - * @param startContainerID start container ID. - * @param count count, if count {@literal <} 0, the max size is unlimited.( - * Usually the count will be replace with a very big - * value instead of being unlimited in case the db is very big) - * @param state Container with this state will be returned. - * @param replicationConfig Replication config for the containers - * @return a list of containers capped by max count allowed - * in "ozone.scm.container.list.max.count" and total number of containers. - * @throws IOException - */ - ContainerListResult listContainer(long startContainerID, - int count, HddsProtos.LifeCycleState state, - HddsProtos.ReplicationType replicationType, - ReplicationConfig replicationConfig) throws IOException; - - /** - * Ask SCM for a list of containers with a range of container ID, state - * and replication config, and the limit of count. - * The containers are returned from startID (exclusive), and - * filtered by state and replication config. The returned list is limited to - * count entries. - * - * @param startContainerID start container ID. - * @param count count, if count {@literal <} 0, the max size is unlimited.( - * Usually the count will be replace with a very big - * value instead of being unlimited in case the db is very big) - * @param state Container with this state will be returned. - * @param replicationConfig Replication config for the containers - * @param suppressed container to be suppressed/unsuppressed from report - * @return a list of containers capped by max count allowed - * in "ozone.scm.container.list.max.count" and total number of containers. - * @throws IOException - */ - ContainerListResult listContainer(long startContainerID, - int count, HddsProtos.LifeCycleState state, - HddsProtos.ReplicationType replicationType, - ReplicationConfig replicationConfig, - Boolean suppressed) throws IOException; - - /** - * Deletes a container in SCM. - * - * @param containerID - * @throws IOException - * if failed to delete the container mapping from db store - * or container doesn't exist. - */ - void deleteContainer(long containerID) throws IOException; - - /** - * Gets the list of underReplicated and unClosed containers on a decommissioning node. - * - * @param dn - Datanode detail - * @return Lists of underReplicated and unClosed containers - */ - Map> getContainersOnDecomNode(DatanodeDetails dn) throws IOException; - - /** - * Queries a list of Node Statuses. Passing a null for either opState or - * state acts like a wildcard returning all nodes in that state. - * @param opState The node operational state - * @param state The node health - * @param clientVersion Client's version number - * @return List of Datanodes. - * @see org.apache.hadoop.ozone.ClientVersion - */ - List queryNode(HddsProtos.NodeOperationalState opState, - HddsProtos.NodeState state, HddsProtos.QueryScope queryScope, - String poolName, int clientVersion) throws IOException; - - HddsProtos.Node queryNode(UUID uuid) throws IOException; - - List decommissionNodes(List nodes, boolean force) - throws IOException; - - List recommissionNodes(List nodes) - throws IOException; - - List startMaintenanceNodes(List nodes, - int endInHours, boolean force) throws IOException; - - /** - * Close a container. - * - * @param containerID ID of the container to close - * @throws IOException in case of any Exception - */ - void closeContainer(long containerID) throws IOException; - - /** - * Creates a replication pipeline of a specified type. - * @param type - replication type - * @param factor - factor 1 or 3 - * @param nodePool - optional machine list to build a pipeline. - * @throws IOException - */ - Pipeline createReplicationPipeline(HddsProtos.ReplicationType type, - HddsProtos.ReplicationFactor factor, HddsProtos.NodePool nodePool) - throws IOException; - - /** - * Returns the list of active Pipelines. - * - * @return list of Pipeline - * - * @throws IOException in case of any exception - */ - List listPipelines() throws IOException; - - /** - * Returns Pipeline with given ID if present. - * - * @return Pipeline - * - * @throws IOException in case of any exception - */ - Pipeline getPipeline(HddsProtos.PipelineID pipelineID) throws IOException; - - /** - * Activates a dormant pipeline. - * - * @param pipelineID ID of the pipeline to activate. - * @throws IOException in case of any Exception - */ - void activatePipeline(HddsProtos.PipelineID pipelineID) throws IOException; - - /** - * Deactivates an active pipeline. - * - * @param pipelineID ID of the pipeline to deactivate. - * @throws IOException in case of any Exception - */ - void deactivatePipeline(HddsProtos.PipelineID pipelineID) throws IOException; - - /** - * Closes a pipeline given the pipelineID. - * - * @param pipelineID ID of the pipeline to demolish - * @throws IOException - */ - void closePipeline(HddsProtos.PipelineID pipelineID) throws IOException; - - /** - * Returns information about SCM. - * - * @return {@link ScmInfo} - * @throws IOException - */ - ScmInfo getScmInfo() throws IOException; - - /** - * Transfer the raft leadership. - * - * @param newLeaderId the newLeaderId of the target expected leader - * @throws IOException - */ - void transferLeadership(String newLeaderId) throws IOException; - - /** - * Return the failed transactions of the Deleted blocks. A transaction is - * considered to be failed if it has been sent more than MAX_RETRY limit - * and its count is reset to -1. - * - * @param count Maximum num of returned transactions, if {@literal < 0}. return all. - * @param startTxId The least transaction id to start with. - * @return a list of failed deleted block transactions. - * @throws IOException - */ - @Deprecated - List getFailedDeletedBlockTxn(int count, - long startTxId) throws IOException; - - /** - * Reset the failed deleted block retry count. - * - * @param txIDs transactionId list to be reset - * @return num of successful reset - * @throws IOException - */ - @Deprecated - int resetDeletedBlockRetryCount(List txIDs) throws IOException; - - - /** - * Get deleted block summary. - * @throws IOException - */ - @Nullable - DeletedBlocksTransactionSummary getDeletedBlockSummary() throws IOException; - - /** - * Check if SCM is in safe mode. - * - * @return Returns true if SCM is in safe mode else returns false. - * @throws IOException - */ - boolean inSafeMode() throws IOException; - - List getSafeModeRuleStatuses() throws IOException; - - /** - * Force SCM out of Safe mode. - * - * @return returns true if operation is successful. - * @throws IOException - */ - boolean forceExitSafeMode() throws IOException; - - /** - * Start ReplicationManager. - */ - void startReplicationManager() throws IOException; - - /** - * Stop ReplicationManager. - */ - void stopReplicationManager() throws IOException; - - /** - * Returns ReplicationManager status. - * - * @return True if ReplicationManager is running, false otherwise. - */ - boolean getReplicationManagerStatus() throws IOException; - - /** - * Returns the latest container summary report generated by Replication - * Manager. - * @return The latest ReplicationManagerReport. - * @throws IOException - */ - ReplicationManagerReport getReplicationManagerReport() throws IOException; - - /** - * Start ContainerBalancer. - * @return {@link StartContainerBalancerResponseProto} that contains the - * start status and an optional message. - */ - @SuppressWarnings("checkstyle:parameternumber") - StartContainerBalancerResponseProto startContainerBalancer( - Optional threshold, - Optional iterations, - Optional maxDatanodesPercentageToInvolvePerIteration, - Optional maxSizeToMovePerIterationInGB, - Optional maxSizeEnteringTargetInGB, - Optional maxSizeLeavingSourceInGB, - Optional balancingInterval, - Optional moveTimeout, - Optional moveReplicationTimeout, - Optional networkTopologyEnable, - Optional includeNodes, - Optional excludeNodes, - Optional excludeContainers, - Optional includeContainers) throws IOException; - - /** - * Stop ContainerBalancer. - */ - void stopContainerBalancer() throws IOException; - - /** - * Returns ContainerBalancer status. - * - * @return True if ContainerBalancer is running, false otherwise. - */ - boolean getContainerBalancerStatus() throws IOException; - - ContainerBalancerStatusInfoResponseProto getContainerBalancerStatusInfo() throws IOException; - - /** - * Get Datanode usage information by ip or hostname or uuid. - * - * @param address datanode IP address or Hostname String - * @param uuid datanode UUID String - * @param clientVersion Client's version number - * @return List of DatanodeUsageInfoProto. Each element contains info such as - * capacity, SCMused, and remaining space. - * @throws IOException - * @see org.apache.hadoop.ozone.ClientVersion - */ - List getDatanodeUsageInfo( - String address, String uuid, int clientVersion) throws IOException; - - /** - * Get usage information of most or least used datanodes. - * - * @param mostUsed true if most used, false if least used - * @param count Integer number of nodes to get info for - * @param clientVersion Client's version number - * @return List of DatanodeUsageInfoProto. Each element contains info such as - * capacity, SCMUsed, and remaining space. - * @throws IOException - * @see org.apache.hadoop.ozone.ClientVersion - */ - List getDatanodeUsageInfo( - boolean mostUsed, int count, int clientVersion) throws IOException; - - StatusAndMessages finalizeScmUpgrade(String upgradeClientID) - throws IOException; - - StatusAndMessages queryUpgradeFinalizationProgress( - String upgradeClientID, boolean force, boolean readonly) - throws IOException; - - /** - * Obtain a token which can be used to let datanodes verify authentication of - * commands operating on {@code containerID}. - */ - Token getContainerToken(ContainerID containerID) throws IOException; - - long getContainerCount() throws IOException; - - long getContainerCount(HddsProtos.LifeCycleState state) - throws IOException; - - List getListOfContainerIDs( - ContainerID startContainerID, int count, HddsProtos.LifeCycleState state) - throws IOException; - - DecommissionScmResponseProto decommissionScm( - String scmId) throws IOException; - - String getMetrics(String query) throws IOException; - - /** - * Trigger a reconcile command to datanodes for the current container ID. - * - * @param containerID The ID of the container to reconcile. - * @throws IOException On error - */ - void reconcileContainer(long containerID) throws IOException; - - /** - * Suppress or unsuppress containers from reports. - * - * @param containerIds container IDs to suppress or unsuppress - * @param suppress true to suppress, false to unsuppress - * @throws IOException - */ - List suppressContainers(List containerIds, boolean suppress) throws IOException; +public final class StorageContainerLocationProtocol { + // Do not add anything here. } diff --git a/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/scm/protocolPB/StorageContainerLocationProtocolClientSideTranslatorPB.java b/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/scm/protocolPB/StorageContainerLocationProtocolClientSideTranslatorPB.java index 7cdb5fa33652..88991959f8a2 100644 --- a/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/scm/protocolPB/StorageContainerLocationProtocolClientSideTranslatorPB.java +++ b/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/scm/protocolPB/StorageContainerLocationProtocolClientSideTranslatorPB.java @@ -137,7 +137,7 @@ import org.apache.hadoop.hdds.scm.container.ReplicationManagerReport; import org.apache.hadoop.hdds.scm.container.common.helpers.ContainerWithPipeline; import org.apache.hadoop.hdds.scm.pipeline.Pipeline; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.proxy.SCMContainerLocationFailoverProxyProvider; import org.apache.hadoop.hdds.tracing.TracingUtil; import org.apache.hadoop.io_.retry.RetryProxy; @@ -154,12 +154,12 @@ /** * This class is the client-side translator to translate the requests made on - * the {@link StorageContainerLocationProtocol} interface to the RPC server + * the {@link StorageContainerLocationInternalInterface} interface to the RPC server * implementing {@link StorageContainerLocationProtocolPB}. */ @InterfaceAudience.Private public final class StorageContainerLocationProtocolClientSideTranslatorPB - implements StorageContainerLocationProtocol, ProtocolTranslator, Closeable { + implements StorageContainerLocationInternalInterface, ProtocolTranslator, Closeable { /** * RpcController is not used and hence is set to null. diff --git a/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/utils/HAUtils.java b/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/utils/HAUtils.java index 3ae1b451e1fc..6a091b0a7e8c 100644 --- a/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/utils/HAUtils.java +++ b/hadoop-hdds/framework/src/main/java/org/apache/hadoop/hdds/utils/HAUtils.java @@ -50,7 +50,7 @@ import org.apache.hadoop.hdds.scm.ScmInfo; import org.apache.hadoop.hdds.scm.ha.SCMHAUtils; import org.apache.hadoop.hdds.scm.protocol.ScmBlockLocationProtocol; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.protocolPB.ScmBlockLocationProtocolClientSideTranslatorPB; import org.apache.hadoop.hdds.scm.protocolPB.StorageContainerLocationProtocolClientSideTranslatorPB; import org.apache.hadoop.hdds.scm.protocolPB.StorageContainerLocationProtocolClientSideTranslatorPB.ScmNodeTarget; @@ -139,38 +139,38 @@ public static ScmBlockLocationProtocol getScmBlockClient( conf); } - public static StorageContainerLocationProtocol getScmContainerClient( + public static StorageContainerLocationInternalInterface getScmContainerClient( ConfigurationSource conf) { SCMContainerLocationFailoverProxyProvider proxyProvider = new SCMContainerLocationFailoverProxyProvider(conf, null); - StorageContainerLocationProtocol scmContainerClient = + StorageContainerLocationInternalInterface scmContainerClient = TracingUtil.createProxy( new StorageContainerLocationProtocolClientSideTranslatorPB( - proxyProvider), StorageContainerLocationProtocol.class, conf); + proxyProvider), StorageContainerLocationInternalInterface.class, conf); return scmContainerClient; } @VisibleForTesting - public static StorageContainerLocationProtocol getScmContainerClient( + public static StorageContainerLocationInternalInterface getScmContainerClient( ConfigurationSource conf, UserGroupInformation userGroupInformation) { SCMContainerLocationFailoverProxyProvider proxyProvider = new SCMContainerLocationFailoverProxyProvider(conf, userGroupInformation); - StorageContainerLocationProtocol scmContainerClient = + StorageContainerLocationInternalInterface scmContainerClient = TracingUtil.createProxy( new StorageContainerLocationProtocolClientSideTranslatorPB( - proxyProvider), StorageContainerLocationProtocol.class, conf); + proxyProvider), StorageContainerLocationInternalInterface.class, conf); return scmContainerClient; } - public static StorageContainerLocationProtocol getScmContainerClientForNode( + public static StorageContainerLocationInternalInterface getScmContainerClientForNode( ConfigurationSource conf, ScmNodeTarget targetScmNode) { SCMContainerLocationFailoverProxyProvider proxyProvider = new SCMContainerLocationFailoverProxyProvider(conf, null); - StorageContainerLocationProtocol scmContainerClient = + StorageContainerLocationInternalInterface scmContainerClient = TracingUtil.createProxy( new StorageContainerLocationProtocolClientSideTranslatorPB( - proxyProvider, targetScmNode), StorageContainerLocationProtocol.class, conf); + proxyProvider, targetScmNode), StorageContainerLocationInternalInterface.class, conf); return scmContainerClient; } diff --git a/hadoop-hdds/framework/src/test/java/org/apache/hadoop/hdds/scm/protocolPB/TestStorageContainerLocationProtocolPB.java b/hadoop-hdds/framework/src/test/java/org/apache/hadoop/hdds/scm/protocolPB/TestStorageContainerLocationProtocolPB.java index 7c88043a225a..441640ac8892 100644 --- a/hadoop-hdds/framework/src/test/java/org/apache/hadoop/hdds/scm/protocolPB/TestStorageContainerLocationProtocolPB.java +++ b/hadoop-hdds/framework/src/test/java/org/apache/hadoop/hdds/scm/protocolPB/TestStorageContainerLocationProtocolPB.java @@ -18,9 +18,13 @@ package org.apache.hadoop.hdds.scm.protocolPB; import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import java.lang.reflect.Modifier; import org.apache.hadoop.hdds.scm.ScmConfig; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; import org.apache.hadoop.ipc_.RPC; import org.apache.hadoop.security.KerberosInfo; @@ -44,4 +48,11 @@ public void testProtocolMetadata() { assertEquals(ScmConfig.ConfigStrings.HDDS_SCM_KERBEROS_PRINCIPAL_KEY, kerberosInfo.serverPrincipal()); } + + @Test + public void testProtocolIdentityIsSeparateFromInternalInterface() { + assertFalse(StorageContainerLocationProtocol.class.isInterface()); + assertTrue(Modifier.isFinal(StorageContainerLocationProtocol.class.getModifiers())); + assertTrue(StorageContainerLocationInternalInterface.class.isInterface()); + } } diff --git a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/protocol/StorageContainerLocationProtocolServerSideTranslatorPB.java b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/protocol/StorageContainerLocationProtocolServerSideTranslatorPB.java index c1561f0cd19c..0fd99dec24b9 100644 --- a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/protocol/StorageContainerLocationProtocolServerSideTranslatorPB.java +++ b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/protocol/StorageContainerLocationProtocolServerSideTranslatorPB.java @@ -28,8 +28,9 @@ import static org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.Type.GetPipeline; import static org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.Type.ListContainer; import static org.apache.hadoop.hdds.protocol.proto.StorageContainerLocationProtocolProtos.Type.ListPipelines; -import static org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol.ADMIN_COMMAND_TYPE; -import static org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol.FOLLOWER_READABLE_COMMAND_TYPES; +import static org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface.ADMIN_COMMAND_TYPE; +import static org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface + .FOLLOWER_READABLE_COMMAND_TYPES; import com.google.protobuf.RpcController; import com.google.protobuf.ServiceException; @@ -160,7 +161,7 @@ /** * This class is the server-side translator that forwards requests received on * {@link StorageContainerLocationProtocolPB} to the - * {@link StorageContainerLocationProtocol} server implementation. + * {@link StorageContainerLocationInternalInterface} server implementation. */ @InterfaceAudience.Private @SuppressWarnings({"method"}) @@ -181,7 +182,7 @@ public final class StorageContainerLocationProtocolServerSideTranslatorPB + " Please upgrade the client to a version that supports Erasure" + " Coded data, and retry!"; - private final StorageContainerLocationProtocol impl; + private final StorageContainerLocationInternalInterface impl; private final StorageContainerManager scm; private static final String ROLE_TYPE = "SCM"; @@ -192,12 +193,12 @@ public final class StorageContainerLocationProtocolServerSideTranslatorPB /** * Creates a new StorageContainerLocationProtocolServerSideTranslatorPB. * - * @param impl {@link StorageContainerLocationProtocol} server + * @param impl {@link StorageContainerLocationInternalInterface} server * implementation * @param protocolMetrics */ public StorageContainerLocationProtocolServerSideTranslatorPB( - StorageContainerLocationProtocol impl, + StorageContainerLocationInternalInterface impl, StorageContainerManager scm, ProtocolMessageMetrics protocolMetrics) throws IOException { diff --git a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/server/SCMClientProtocolServer.java b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/server/SCMClientProtocolServer.java index 96b9efce50f7..8923cf61d14d 100644 --- a/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/server/SCMClientProtocolServer.java +++ b/hadoop-hdds/server-scm/src/main/java/org/apache/hadoop/hdds/scm/server/SCMClientProtocolServer.java @@ -99,7 +99,7 @@ import org.apache.hadoop.hdds.scm.pipeline.PipelineID; import org.apache.hadoop.hdds.scm.pipeline.PipelineManager; import org.apache.hadoop.hdds.scm.pipeline.PipelineNotFoundException; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocolServerSideTranslatorPB; import org.apache.hadoop.hdds.scm.protocolPB.StorageContainerLocationProtocolPB; import org.apache.hadoop.hdds.security.SecurityConfig; @@ -132,7 +132,7 @@ * The RPC server that listens to requests from clients. */ public class SCMClientProtocolServer implements - StorageContainerLocationProtocol, Auditor { + StorageContainerLocationInternalInterface, Auditor { private static final Logger LOG = LoggerFactory.getLogger(SCMClientProtocolServer.class); private static final AuditLogger AUDIT = diff --git a/hadoop-ozone/cli-admin/src/main/java/org/apache/hadoop/hdds/scm/cli/ContainerOperationClient.java b/hadoop-ozone/cli-admin/src/main/java/org/apache/hadoop/hdds/scm/cli/ContainerOperationClient.java index 7fee21620d15..d480f4379dec 100644 --- a/hadoop-ozone/cli-admin/src/main/java/org/apache/hadoop/hdds/scm/cli/ContainerOperationClient.java +++ b/hadoop-ozone/cli-admin/src/main/java/org/apache/hadoop/hdds/scm/cli/ContainerOperationClient.java @@ -51,7 +51,7 @@ import org.apache.hadoop.hdds.scm.container.ReplicationManagerReport; import org.apache.hadoop.hdds.scm.container.common.helpers.ContainerWithPipeline; import org.apache.hadoop.hdds.scm.pipeline.Pipeline; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.protocolPB.StorageContainerLocationProtocolClientSideTranslatorPB.ScmNodeTarget; import org.apache.hadoop.hdds.scm.storage.ContainerProtocolCalls; import org.apache.hadoop.hdds.security.x509.certificate.client.CACertificateProvider; @@ -70,7 +70,7 @@ public class ContainerOperationClient implements ScmClient { private static final Logger LOG = LoggerFactory.getLogger(ContainerOperationClient.class); - private final StorageContainerLocationProtocol + private final StorageContainerLocationInternalInterface storageContainerLocationClient; private final SecretKeyProtocolScm secretKeyClient; private final boolean containerTokenEnabled; @@ -119,12 +119,12 @@ private XceiverClientManager newXCeiverClientManager(ConfigurationSource conf) return manager; } - public static StorageContainerLocationProtocol newContainerRpcClient( + public static StorageContainerLocationInternalInterface newContainerRpcClient( ConfigurationSource configSource) { return HAUtils.getScmContainerClient(configSource); } - public static StorageContainerLocationProtocol newContainerRpcClientForNode( + public static StorageContainerLocationInternalInterface newContainerRpcClientForNode( ConfigurationSource configSource, ScmNodeTarget targetScmNode) { return HAUtils.getScmContainerClientForNode(configSource, targetScmNode); } diff --git a/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/BaseFreonGenerator.java b/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/BaseFreonGenerator.java index 541e061b49b1..28979e6fac3f 100644 --- a/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/BaseFreonGenerator.java +++ b/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/BaseFreonGenerator.java @@ -46,7 +46,7 @@ import org.apache.hadoop.hdds.conf.OzoneConfiguration; import org.apache.hadoop.hdds.conf.TimeDurationUtil; import org.apache.hadoop.hdds.scm.pipeline.Pipeline; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.tracing.TracingUtil; import org.apache.hadoop.hdds.utils.HAUtils; import org.apache.hadoop.ipc_.ProtobufRpcEngine; @@ -444,14 +444,14 @@ public OzoneManagerProtocolClientSideTranslatorPB createOmClient( return new OzoneManagerProtocolClientSideTranslatorPB(transport, clientId); } - public StorageContainerLocationProtocol createStorageContainerLocationClient( + public StorageContainerLocationInternalInterface createStorageContainerLocationClient( OzoneConfiguration ozoneConf) throws IOException { return HAUtils.getScmContainerClient(ozoneConf); } @SuppressWarnings("java:S3864") // Stream.peek (for debug) public static Pipeline findPipelineForTest(String pipelineId, - StorageContainerLocationProtocol client, Logger log) throws IOException { + StorageContainerLocationInternalInterface client, Logger log) throws IOException { Stream pipelines = client.listPipelines().stream(); Pipeline pipeline; if (log.isDebugEnabled()) { diff --git a/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/DatanodeBlockPutter.java b/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/DatanodeBlockPutter.java index a5361a46d2c2..b3252ee93bc6 100644 --- a/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/DatanodeBlockPutter.java +++ b/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/DatanodeBlockPutter.java @@ -35,7 +35,7 @@ import org.apache.hadoop.hdds.scm.XceiverClientFactory; import org.apache.hadoop.hdds.scm.XceiverClientSpi; import org.apache.hadoop.hdds.scm.pipeline.Pipeline; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.ozone.OzoneSecurityUtil; import org.apache.hadoop.ozone.common.Checksum; import org.kohsuke.MetaInfServices; @@ -96,7 +96,7 @@ public Void call() throws Exception { "datanode-block-putter is not supported in secure environment"); } - try (StorageContainerLocationProtocol scmLocationClient = + try (StorageContainerLocationInternalInterface scmLocationClient = createStorageContainerLocationClient(ozoneConf)) { Pipeline pipeline = findPipelineForTest(pipelineId, scmLocationClient, LOG); diff --git a/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/DatanodeChunkGenerator.java b/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/DatanodeChunkGenerator.java index ca9c17519135..c27cdf4c24f1 100644 --- a/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/DatanodeChunkGenerator.java +++ b/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/DatanodeChunkGenerator.java @@ -43,7 +43,7 @@ import org.apache.hadoop.hdds.scm.XceiverClientReply; import org.apache.hadoop.hdds.scm.XceiverClientSpi; import org.apache.hadoop.hdds.scm.pipeline.Pipeline; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.ozone.OzoneSecurityUtil; import org.apache.hadoop.ozone.common.Checksum; import org.apache.ratis.thirdparty.com.google.protobuf.ByteString; @@ -115,7 +115,7 @@ public Void call() throws Exception { Set pipelines; - try (StorageContainerLocationProtocol scmLocationClient = + try (StorageContainerLocationInternalInterface scmLocationClient = createStorageContainerLocationClient(ozoneConf); XceiverClientFactory xceiverClientManager = new XceiverClientCreator(ozoneConf)) { diff --git a/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/DatanodeChunkValidator.java b/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/DatanodeChunkValidator.java index b17a6b54fbfd..4acb7c577d88 100644 --- a/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/DatanodeChunkValidator.java +++ b/hadoop-ozone/freon/src/main/java/org/apache/hadoop/ozone/freon/DatanodeChunkValidator.java @@ -29,7 +29,7 @@ import org.apache.hadoop.hdds.scm.XceiverClientFactory; import org.apache.hadoop.hdds.scm.XceiverClientSpi; import org.apache.hadoop.hdds.scm.pipeline.Pipeline; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.ozone.OzoneSecurityUtil; import org.apache.hadoop.ozone.common.Checksum; import org.apache.hadoop.ozone.common.ChecksumData; @@ -88,7 +88,7 @@ public Void call() throws Exception { ); } - try (StorageContainerLocationProtocol scmClient = + try (StorageContainerLocationInternalInterface scmClient = createStorageContainerLocationClient(ozoneConf)) { Pipeline pipeline = findPipelineForTest(pipelineId, scmClient, LOG); diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/TestFailoverWithSCMHA.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/TestFailoverWithSCMHA.java index c2c7b3c6e23c..c98c7d767c3c 100644 --- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/TestFailoverWithSCMHA.java +++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/scm/TestFailoverWithSCMHA.java @@ -37,7 +37,7 @@ import org.apache.hadoop.hdds.scm.container.balancer.IllegalContainerBalancerStateException; import org.apache.hadoop.hdds.scm.container.balancer.InvalidContainerBalancerConfigurationException; import org.apache.hadoop.hdds.scm.protocol.ScmBlockLocationProtocol; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.protocolPB.ScmBlockLocationProtocolClientSideTranslatorPB; import org.apache.hadoop.hdds.scm.protocolPB.StorageContainerLocationProtocolClientSideTranslatorPB; import org.apache.hadoop.hdds.scm.proxy.SCMBlockLocationFailoverProxyProvider; @@ -131,10 +131,10 @@ public void testFailover() throws Exception { Level.DEBUG); logCapture = LogCapturer.captureLogs(SCMContainerLocationFailoverProxyProvider.class); proxyProvider.changeCurrentProxy(scm.getSCMNodeId()); - StorageContainerLocationProtocol scmContainerClient = + StorageContainerLocationInternalInterface scmContainerClient = TracingUtil.createProxy( new StorageContainerLocationProtocolClientSideTranslatorPB( - proxyProvider), StorageContainerLocationProtocol.class, conf); + proxyProvider), StorageContainerLocationInternalInterface.class, conf); scmContainerClient.allocateContainer(HddsProtos.ReplicationType.RATIS, HddsProtos.ReplicationFactor.ONE, "ozone"); diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/HddsUpgradeTestUtils.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/HddsUpgradeTestUtils.java index eea584643e6e..9517d36e1345 100644 --- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/HddsUpgradeTestUtils.java +++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/HddsUpgradeTestUtils.java @@ -41,7 +41,7 @@ import org.apache.hadoop.hdds.scm.container.ContainerInfo; import org.apache.hadoop.hdds.scm.node.states.NodeNotFoundException; import org.apache.hadoop.hdds.scm.pipeline.PipelineManager; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.StorageContainerManager; import org.apache.hadoop.hdds.scm.server.upgrade.FinalizationCheckpoint; import org.apache.hadoop.ozone.HddsDatanodeService; @@ -67,7 +67,7 @@ public final class HddsUpgradeTestUtils { private HddsUpgradeTestUtils() { } public static void waitForFinalizationFromClient( - StorageContainerLocationProtocol scmClient, String clientID) + StorageContainerLocationInternalInterface scmClient, String clientID) throws Exception { LambdaTestUtils.await(60_000, 1_000, () -> { UpgradeFinalization.Status status = scmClient diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/TestDNDataDistributionFinalization.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/TestDNDataDistributionFinalization.java index 7caf91294d70..623b538342cc 100644 --- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/TestDNDataDistributionFinalization.java +++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/TestDNDataDistributionFinalization.java @@ -33,7 +33,7 @@ import java.util.concurrent.TimeUnit; import org.apache.hadoop.hdds.conf.OzoneConfiguration; import org.apache.hadoop.hdds.scm.ScmConfig; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.SCMConfigurator; import org.apache.hadoop.hdds.scm.server.SCMStorageConfig; import org.apache.hadoop.ozone.HddsDatanodeService; @@ -66,7 +66,7 @@ public class TestDNDataDistributionFinalization { private static final Logger LOG = LoggerFactory.getLogger(TestDNDataDistributionFinalization.class); - private StorageContainerLocationProtocol scmClient; + private StorageContainerLocationInternalInterface scmClient; private MiniOzoneHAClusterImpl cluster; private static final int NUM_DATANODES = 3; diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/TestScmDataDistributionFinalization.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/TestScmDataDistributionFinalization.java index a1a8ca88c3d8..7d8b08adaae9 100644 --- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/TestScmDataDistributionFinalization.java +++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/TestScmDataDistributionFinalization.java @@ -59,7 +59,7 @@ import org.apache.hadoop.hdds.scm.block.SCMDeletedBlockTransactionStatusManager; import org.apache.hadoop.hdds.scm.ha.SCMHADBTransactionBuffer; import org.apache.hadoop.hdds.scm.metadata.DBTransactionBuffer; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.SCMConfigurator; import org.apache.hadoop.hdds.scm.server.SCMStorageConfig; import org.apache.hadoop.hdds.scm.server.StorageContainerManager; @@ -98,7 +98,7 @@ public class TestScmDataDistributionFinalization { private static final Logger LOG = LoggerFactory.getLogger(TestScmDataDistributionFinalization.class); - private StorageContainerLocationProtocol scmClient; + private StorageContainerLocationInternalInterface scmClient; private MiniOzoneHAClusterImpl cluster; private static final int NUM_DATANODES = 3; private static final int NUM_SCMS = 3; diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/TestScmHAFinalization.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/TestScmHAFinalization.java index c0e64ac4cacc..f5aa45c43e81 100644 --- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/TestScmHAFinalization.java +++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/hdds/upgrade/TestScmHAFinalization.java @@ -36,7 +36,7 @@ import org.apache.hadoop.hdds.protocol.proto.HddsProtos; import org.apache.hadoop.hdds.scm.ScmConfigKeys; import org.apache.hadoop.hdds.scm.container.common.helpers.ContainerWithPipeline; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.SCMConfigurator; import org.apache.hadoop.hdds.scm.server.SCMStorageConfig; import org.apache.hadoop.hdds.scm.server.StorageContainerManager; @@ -73,7 +73,7 @@ public class TestScmHAFinalization { "org.apache.hadoop.hdds.upgrade" + ".TestScmHAFinalization#injectionPointsToTest"; - private StorageContainerLocationProtocol scmClient; + private StorageContainerLocationInternalInterface scmClient; private MiniOzoneHAClusterImpl cluster; private static final int NUM_DATANODES = 3; private static final int NUM_SCMS = 3; diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestOMSortDatanodes.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestOMSortDatanodes.java index a206276ce8fd..6ff81b327bcf 100644 --- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestOMSortDatanodes.java +++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestOMSortDatanodes.java @@ -37,7 +37,7 @@ import org.apache.hadoop.hdds.scm.ha.SCMContext; import org.apache.hadoop.hdds.scm.ha.SCMHAManagerStub; import org.apache.hadoop.hdds.scm.node.NodeManager; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.SCMConfigurator; import org.apache.hadoop.hdds.scm.server.StorageContainerManager; import org.apache.hadoop.net.StaticMapping; @@ -100,7 +100,8 @@ public static void setup() throws Exception { scm.exitSafeMode(); nodeManager = scm.getScmNodeManager(); datanodes.forEach(dn -> nodeManager.register(dn, null, null)); - StorageContainerLocationProtocol mockScmContainerClient = mock(StorageContainerLocationProtocol.class); + StorageContainerLocationInternalInterface mockScmContainerClient = + mock(StorageContainerLocationInternalInterface.class); OmTestManagers omTestManagers = new OmTestManagers(config, scm.getBlockProtocolServer(), mockScmContainerClient); diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestSecureOzoneCluster.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestSecureOzoneCluster.java index e6178ee380cf..9518a33479d5 100644 --- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestSecureOzoneCluster.java +++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/TestSecureOzoneCluster.java @@ -102,7 +102,7 @@ import org.apache.hadoop.hdds.scm.ScmInfo; import org.apache.hadoop.hdds.scm.client.ScmTopologyClient; import org.apache.hadoop.hdds.scm.protocol.ScmBlockLocationProtocol; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.SCMStorageConfig; import org.apache.hadoop.hdds.scm.server.StorageContainerManager; import org.apache.hadoop.hdds.security.SecurityConfig; @@ -403,7 +403,7 @@ private void assertScmSecurityProtocolRejectsNonKerberosUser() throws Exception private void assertScmAdminProtocolDeniesNonAdminUser() throws IOException { UserGroupInformation ugi = UserGroupInformation.loginUserFromKeytabAndReturnUGI( testUserPrincipal, testUserKeytab.getCanonicalPath()); - StorageContainerLocationProtocol scmRpcClient = + StorageContainerLocationInternalInterface scmRpcClient = HAUtils.getScmContainerClient(conf, ugi); IOException adminException = assertThrows(IOException.class, scmRpcClient::forceExitSafeMode); @@ -414,7 +414,7 @@ private void assertScmAdminProtocolDeniesNonAdminUser() throws IOException { private void assertScmAdminProtocolRejectsNonKerberosUser() throws IOException { UserGroupInformation ugi = UserGroupInformation.createRemoteUser("test"); ugi.setAuthenticationMethod(AuthMethod.TOKEN); - StorageContainerLocationProtocol scmRpcClient = + StorageContainerLocationInternalInterface scmRpcClient = HAUtils.getScmContainerClient(conf, ugi); IOException adminException = assertThrows(IOException.class, scmRpcClient::forceExitSafeMode); diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestKeyManagerImpl.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestKeyManagerImpl.java index 53748acd0e6f..5ccb8f71406c 100644 --- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestKeyManagerImpl.java +++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestKeyManagerImpl.java @@ -102,7 +102,7 @@ import org.apache.hadoop.hdds.scm.pipeline.Pipeline; import org.apache.hadoop.hdds.scm.pipeline.PipelineID; import org.apache.hadoop.hdds.scm.protocol.ScmBlockLocationProtocol; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.SCMConfigurator; import org.apache.hadoop.hdds.scm.server.StorageContainerManager; import org.apache.hadoop.hdds.utils.db.InMemoryTestTable; @@ -158,7 +158,7 @@ public class TestKeyManagerImpl { private static KeyManagerImpl keyManager; private static StorageContainerManager scm; private static ScmBlockLocationProtocol mockScmBlockLocationProtocol; - private static StorageContainerLocationProtocol mockScmContainerClient; + private static StorageContainerLocationInternalInterface mockScmContainerClient; private static OzoneConfiguration conf; private static OMMetadataManager metadataManager; private static long scmBlockSize; @@ -208,7 +208,7 @@ public static void setUp() throws Exception { conf.setLong(OZONE_KEY_PREALLOCATION_BLOCKS_MAX, 10); mockScmContainerClient = - mock(StorageContainerLocationProtocol.class); + mock(StorageContainerLocationInternalInterface.class); OmTestManagers omTestManagers = new OmTestManagers(conf, scm.getBlockProtocolServer(), @@ -1355,8 +1355,8 @@ public void testRefreshPipeline() throws Exception { OzoneManager ozoneManager = om; - StorageContainerLocationProtocol sclProtocolMock = mock( - StorageContainerLocationProtocol.class); + StorageContainerLocationInternalInterface sclProtocolMock = mock( + StorageContainerLocationInternalInterface.class); OMPerformanceMetrics metrics = mock(OMPerformanceMetrics.class); List containerIDs = new ArrayList<>(); @@ -1427,8 +1427,8 @@ public void testRefreshPipelineException() throws Exception { OzoneManager ozoneManager = om; String errorMessage = "Cannot find container!!"; - StorageContainerLocationProtocol sclProtocolMock = mock( - StorageContainerLocationProtocol.class); + StorageContainerLocationInternalInterface sclProtocolMock = mock( + StorageContainerLocationInternalInterface.class); doThrow(new IOException(errorMessage)).when(sclProtocolMock) .getContainerWithPipelineBatch(any()); diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestOmContainerLocationCache.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestOmContainerLocationCache.java index e879150c98d2..3d2dbf4393c5 100644 --- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestOmContainerLocationCache.java +++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/TestOmContainerLocationCache.java @@ -92,7 +92,7 @@ import org.apache.hadoop.hdds.scm.pipeline.Pipeline; import org.apache.hadoop.hdds.scm.pipeline.PipelineID; import org.apache.hadoop.hdds.scm.protocol.ScmBlockLocationProtocol; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.security.exception.SCMSecurityException; import org.apache.hadoop.ozone.OzoneConfigKeys; import org.apache.hadoop.ozone.client.ObjectStore; @@ -135,7 +135,7 @@ public class TestOmContainerLocationCache { @TempDir private static File dir; private static ScmBlockLocationProtocol mockScmBlockLocationProtocol; - private static StorageContainerLocationProtocol mockScmContainerClient; + private static StorageContainerLocationInternalInterface mockScmContainerClient; private static OzoneConfiguration conf; private static OMMetadataManager metadataManager; private static final String BUCKET_NAME = "bucket1"; @@ -170,7 +170,7 @@ public static void setUp() throws Exception { mockScmBlockLocationProtocol = mock(ScmBlockLocationProtocol.class); mockScmContainerClient = - mock(StorageContainerLocationProtocol.class); + mock(StorageContainerLocationInternalInterface.class); InnerNode.Factory factory = InnerNodeImpl.FACTORY; when(mockScmBlockLocationProtocol.getNetworkTopology()).thenReturn( factory.newInnerNode("", "", null, NetConstants.ROOT_LEVEL, 1)); diff --git a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/service/TestBlockDeletionService.java b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/service/TestBlockDeletionService.java index d3364c1f7427..f405fc5f201b 100644 --- a/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/service/TestBlockDeletionService.java +++ b/hadoop-ozone/integration-test/src/test/java/org/apache/hadoop/ozone/om/service/TestBlockDeletionService.java @@ -44,7 +44,7 @@ import org.apache.hadoop.hdds.conf.OzoneConfiguration; import org.apache.hadoop.hdds.scm.block.BlockManager; import org.apache.hadoop.hdds.scm.container.placement.metrics.SCMPerformanceMetrics; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.SCMConfigurator; import org.apache.hadoop.hdds.scm.server.SCMStorageConfig; import org.apache.hadoop.hdds.scm.server.StorageContainerManager; @@ -79,7 +79,7 @@ public class TestBlockDeletionService { private static final String BUCKET_NAME = "bucket1"; private static final int KEY_SIZE = 5 * 1024; // 5 KB private static MiniOzoneCluster cluster; - private static StorageContainerLocationProtocol scmClient; + private static StorageContainerLocationInternalInterface scmClient; private static OzoneBucket bucket; private static SCMPerformanceMetrics metrics; diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OzoneManager.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OzoneManager.java index 4254a634b3d4..eaa3d5a4c8e3 100644 --- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OzoneManager.java +++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/OzoneManager.java @@ -200,7 +200,7 @@ import org.apache.hadoop.hdds.scm.ha.SCMNodeInfo; import org.apache.hadoop.hdds.scm.net.NetworkTopology; import org.apache.hadoop.hdds.scm.protocol.ScmBlockLocationProtocol; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.security.SecurityConfig; import org.apache.hadoop.hdds.security.exception.OzoneSecurityException; import org.apache.hadoop.hdds.security.symmetric.DefaultSecretKeyClient; @@ -649,7 +649,7 @@ private OzoneManager(OzoneConfiguration conf, StartupOption startupOption) // Honor property 'hadoop.security.token.service.use_ip' omRpcAddressTxt = new Text(SecurityUtil.buildTokenService(omNodeRpcAddr)); - final StorageContainerLocationProtocol scmContainerClient = getScmContainerClient(configuration); + final StorageContainerLocationInternalInterface scmContainerClient = getScmContainerClient(configuration); // verifies that the SCM info in the OM Version file is correct. final ScmBlockLocationProtocol scmBlockClient = getScmBlockClient(configuration); scmTopologyClient = new ScmTopologyClient(scmBlockClient); @@ -1420,9 +1420,9 @@ private static ScmBlockLocationProtocol getScmBlockClient( /** * Returns a scm container client. * - * @return {@link StorageContainerLocationProtocol} + * @return {@link StorageContainerLocationInternalInterface} */ - private static StorageContainerLocationProtocol getScmContainerClient( + private static StorageContainerLocationInternalInterface getScmContainerClient( OzoneConfiguration conf) { return HAUtils.getScmContainerClient(conf); } diff --git a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/ScmClient.java b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/ScmClient.java index 868a248e909e..eb0f2cd0c414 100644 --- a/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/ScmClient.java +++ b/hadoop-ozone/ozone-manager/src/main/java/org/apache/hadoop/ozone/om/ScmClient.java @@ -45,7 +45,7 @@ import org.apache.hadoop.hdds.protocol.DatanodeID; import org.apache.hadoop.hdds.scm.pipeline.Pipeline; import org.apache.hadoop.hdds.scm.protocol.ScmBlockLocationProtocol; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.ozone.util.CacheMetrics; /** @@ -54,13 +54,13 @@ public class ScmClient { private final ScmBlockLocationProtocol blockClient; - private final StorageContainerLocationProtocol containerClient; + private final StorageContainerLocationInternalInterface containerClient; private final LoadingCache containerLocationCache; private final CacheMetrics containerCacheMetrics; private final CacheMetrics datanodeDetailsCacheMetrics; ScmClient(ScmBlockLocationProtocol blockClient, - StorageContainerLocationProtocol containerClient, + StorageContainerLocationInternalInterface containerClient, OzoneConfiguration configuration) { this.containerClient = containerClient; this.blockClient = blockClient; @@ -77,7 +77,7 @@ public class ScmClient { static LoadingCache createContainerLocationCache( OzoneConfiguration configuration, - StorageContainerLocationProtocol containerClient, + StorageContainerLocationInternalInterface containerClient, Cache datanodeDetailsCache) { int maxSize = configuration.getInt(OZONE_OM_CONTAINER_LOCATION_CACHE_SIZE, OZONE_OM_CONTAINER_LOCATION_CACHE_SIZE_DEFAULT); @@ -148,7 +148,7 @@ public ScmBlockLocationProtocol getBlockClient() { return this.blockClient; } - public StorageContainerLocationProtocol getContainerClient() { + public StorageContainerLocationInternalInterface getContainerClient() { return this.containerClient; } diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/OmTestManagers.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/OmTestManagers.java index 8b74dcd8a3d0..16b54df80a98 100644 --- a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/OmTestManagers.java +++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/OmTestManagers.java @@ -28,7 +28,7 @@ import org.apache.hadoop.hdds.scm.ScmConfigKeys; import org.apache.hadoop.hdds.scm.client.ScmTopologyClient; import org.apache.hadoop.hdds.scm.protocol.ScmBlockLocationProtocol; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.security.token.OzoneBlockTokenSecretManager; import org.apache.hadoop.metrics2.lib.DefaultMetricsSystem; import org.apache.hadoop.ozone.client.OzoneClient; @@ -96,10 +96,10 @@ public OmTestManagers(OzoneConfiguration conf) public OmTestManagers(OzoneConfiguration conf, ScmBlockLocationProtocol blockClient, - StorageContainerLocationProtocol containerClient) + StorageContainerLocationInternalInterface containerClient) throws AuthenticationException, IOException, InterruptedException, TimeoutException { if (containerClient == null) { - containerClient = mock(StorageContainerLocationProtocol.class); + containerClient = mock(StorageContainerLocationInternalInterface.class); } scmBlockClient = blockClient != null ? blockClient : new ScmBlockLocationTestingClient(null, null, 0); diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestKeyManagerUnit.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestKeyManagerUnit.java index e7df8077cc37..ea6d7096cd9b 100644 --- a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestKeyManagerUnit.java +++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestKeyManagerUnit.java @@ -60,7 +60,7 @@ import org.apache.hadoop.hdds.scm.pipeline.Pipeline; import org.apache.hadoop.hdds.scm.pipeline.PipelineID; import org.apache.hadoop.hdds.scm.protocol.ScmBlockLocationProtocol; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.utils.db.cache.CacheKey; import org.apache.hadoop.hdds.utils.db.cache.CacheValue; import org.apache.hadoop.ozone.OzoneConsts; @@ -103,7 +103,7 @@ class TestKeyManagerUnit extends OzoneTestBase { private static final AtomicLong CONTAINER_ID = new AtomicLong(); private OMMetadataManager metadataManager; - private StorageContainerLocationProtocol containerClient; + private StorageContainerLocationInternalInterface containerClient; private KeyManagerImpl keyManager; private Instant startDate; @@ -117,7 +117,7 @@ void setup(@TempDir Path testDir) throws Exception { ExitUtils.disableSystemExit(); OzoneConfiguration configuration = new OzoneConfiguration(); configuration.set(HddsConfigKeys.OZONE_METADATA_DIRS, testDir.toString()); - containerClient = mock(StorageContainerLocationProtocol.class); + containerClient = mock(StorageContainerLocationInternalInterface.class); blockClient = mock(ScmBlockLocationProtocol.class); InnerNode.Factory factory = InnerNodeImpl.FACTORY; when(blockClient.getNetworkTopology()).thenReturn( diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestScmClient.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestScmClient.java index 89d8c2162c38..179a9b2cb314 100644 --- a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestScmClient.java +++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/TestScmClient.java @@ -50,7 +50,7 @@ import org.apache.hadoop.hdds.scm.pipeline.Pipeline; import org.apache.hadoop.hdds.scm.pipeline.PipelineID; import org.apache.hadoop.hdds.scm.protocol.ScmBlockLocationProtocol; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; import org.junit.jupiter.params.ParameterizedTest; @@ -61,13 +61,13 @@ * ScmClient test-cases. */ public class TestScmClient { - private StorageContainerLocationProtocol containerLocationProtocol; + private StorageContainerLocationInternalInterface containerLocationProtocol; private ScmClient scmClient; @BeforeEach public void setUp() { ScmBlockLocationProtocol scmBlockLocationProtocol = mock(ScmBlockLocationProtocol.class); - containerLocationProtocol = mock(StorageContainerLocationProtocol.class); + containerLocationProtocol = mock(StorageContainerLocationInternalInterface.class); OzoneConfiguration conf = new OzoneConfiguration(); scmClient = new ScmClient(scmBlockLocationProtocol, containerLocationProtocol, conf); diff --git a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/key/OMKeyRequestTests.java b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/key/OMKeyRequestTests.java index 167fbc354a3c..6f71320b4348 100644 --- a/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/key/OMKeyRequestTests.java +++ b/hadoop-ozone/ozone-manager/src/test/java/org/apache/hadoop/ozone/om/request/key/OMKeyRequestTests.java @@ -51,7 +51,7 @@ import org.apache.hadoop.hdds.scm.pipeline.Pipeline; import org.apache.hadoop.hdds.scm.pipeline.PipelineID; import org.apache.hadoop.hdds.scm.protocol.ScmBlockLocationProtocol; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.security.token.OzoneBlockTokenSecretManager; import org.apache.hadoop.hdds.utils.TransactionInfo; import org.apache.hadoop.hdds.utils.db.BatchOperation; @@ -115,7 +115,7 @@ public class OMKeyRequestTests { protected ScmClient scmClient; protected OzoneBlockTokenSecretManager ozoneBlockTokenSecretManager; protected ScmBlockLocationProtocol scmBlockLocationProtocol; - protected StorageContainerLocationProtocol scmContainerLocationProtocol; + protected StorageContainerLocationInternalInterface scmContainerLocationProtocol; protected OMPerformanceMetrics perfMetrics; protected DeletingServiceMetrics delMetrics; @@ -189,7 +189,7 @@ public void setup() throws Exception { when(ozoneManager.getOMServiceId()).thenReturn( UUID.randomUUID().toString()); when(scmClient.getBlockClient()).thenReturn(scmBlockLocationProtocol); - scmContainerLocationProtocol = Mockito.mock(StorageContainerLocationProtocol.class); + scmContainerLocationProtocol = Mockito.mock(StorageContainerLocationInternalInterface.class); when(scmClient.getContainerClient()).thenReturn(scmContainerLocationProtocol); when(ozoneManager.getKeyManager()).thenReturn(keyManager); diff --git a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconControllerModule.java b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconControllerModule.java index cdfdf416561b..4711914e6de0 100644 --- a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconControllerModule.java +++ b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/ReconControllerModule.java @@ -34,7 +34,7 @@ import java.util.concurrent.Executors; import org.apache.commons.lang3.StringUtils; import org.apache.hadoop.hdds.conf.OzoneConfiguration; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.OzoneStorageContainerManager; import org.apache.hadoop.ozone.om.OMMetadataManager; import org.apache.hadoop.ozone.om.protocol.OzoneManagerProtocol; @@ -218,9 +218,9 @@ OzoneManagerProtocol getOzoneManagerProtocol( } @Provides - StorageContainerLocationProtocol getSCMProtocol( + StorageContainerLocationInternalInterface getSCMProtocol( final OzoneConfiguration configuration) { - StorageContainerLocationProtocol storageContainerLocationProtocol = null; + StorageContainerLocationInternalInterface storageContainerLocationProtocol = null; storageContainerLocationProtocol = newContainerRpcClient(configuration); return storageContainerLocationProtocol; } diff --git a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/api/NodeEndpoint.java b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/api/NodeEndpoint.java index 6aacc779bea9..764cf4095914 100644 --- a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/api/NodeEndpoint.java +++ b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/api/NodeEndpoint.java @@ -61,7 +61,7 @@ import org.apache.hadoop.hdds.scm.pipeline.Pipeline; import org.apache.hadoop.hdds.scm.pipeline.PipelineID; import org.apache.hadoop.hdds.scm.pipeline.PipelineNotFoundException; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.OzoneStorageContainerManager; import org.apache.hadoop.ozone.ClientVersion; import org.apache.hadoop.ozone.recon.api.types.DatanodeMetadata; @@ -88,12 +88,12 @@ public class NodeEndpoint { private ReconNodeManager nodeManager; private ReconPipelineManager pipelineManager; private ReconContainerManager reconContainerManager; - private StorageContainerLocationProtocol scmClient; + private StorageContainerLocationInternalInterface scmClient; private String errorMessage = "Error getting pipeline and container metrics for "; @Inject NodeEndpoint(OzoneStorageContainerManager reconSCM, - StorageContainerLocationProtocol scmClient) { + StorageContainerLocationInternalInterface scmClient) { this.nodeManager = (ReconNodeManager) reconSCM.getScmNodeManager(); this.reconContainerManager = diff --git a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/api/PendingDeletionEndpoint.java b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/api/PendingDeletionEndpoint.java index 4554379b6ca4..997d034323ea 100644 --- a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/api/PendingDeletionEndpoint.java +++ b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/api/PendingDeletionEndpoint.java @@ -25,7 +25,7 @@ import javax.ws.rs.QueryParam; import javax.ws.rs.core.Response; import org.apache.hadoop.hdds.protocol.proto.HddsProtos; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.ozone.recon.api.types.DataNodeMetricsCompleteResponse; import org.apache.hadoop.ozone.recon.api.types.ScmPendingDeletion; import org.slf4j.Logger; @@ -42,13 +42,13 @@ public class PendingDeletionEndpoint { private static final Logger LOG = LoggerFactory.getLogger(PendingDeletionEndpoint.class); private final ReconGlobalMetricsService reconGlobalMetricsService; private final DataNodeMetricsService dataNodeMetricsService; - private final StorageContainerLocationProtocol scmClient; + private final StorageContainerLocationInternalInterface scmClient; @Inject public PendingDeletionEndpoint( ReconGlobalMetricsService reconGlobalMetricsService, DataNodeMetricsService dataNodeMetricsService, - StorageContainerLocationProtocol scmClient) { + StorageContainerLocationInternalInterface scmClient) { this.reconGlobalMetricsService = reconGlobalMetricsService; this.dataNodeMetricsService = dataNodeMetricsService; this.scmClient = scmClient; diff --git a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/spi/impl/StorageContainerServiceProviderImpl.java b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/spi/impl/StorageContainerServiceProviderImpl.java index be3d917f42ca..af61f09095b2 100644 --- a/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/spi/impl/StorageContainerServiceProviderImpl.java +++ b/hadoop-ozone/recon/src/main/java/org/apache/hadoop/ozone/recon/spi/impl/StorageContainerServiceProviderImpl.java @@ -42,7 +42,7 @@ import org.apache.hadoop.hdds.scm.ha.InterSCMGrpcClient; import org.apache.hadoop.hdds.scm.ha.SCMSnapshotDownloader; import org.apache.hadoop.hdds.scm.pipeline.Pipeline; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.security.SecurityConfig; import org.apache.hadoop.hdds.utils.db.DBCheckpoint; import org.apache.hadoop.hdds.utils.db.RocksDBCheckpoint; @@ -65,7 +65,7 @@ public class StorageContainerServiceProviderImpl private static final Logger LOG = LoggerFactory.getLogger(StorageContainerServiceProviderImpl.class); - private StorageContainerLocationProtocol scmClient; + private StorageContainerLocationInternalInterface scmClient; private final OzoneConfiguration configuration; private File scmSnapshotDBParentDir; private ReconUtils reconUtils; @@ -74,7 +74,7 @@ public class StorageContainerServiceProviderImpl @Inject public StorageContainerServiceProviderImpl( - StorageContainerLocationProtocol scmClient, + StorageContainerLocationInternalInterface scmClient, ReconUtils reconUtils, OzoneConfiguration configuration, ReconStorageConfig reconStorage, diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestEndpoints.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestEndpoints.java index db9301e4795e..830c3fb8b982 100644 --- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestEndpoints.java +++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestEndpoints.java @@ -94,7 +94,7 @@ import org.apache.hadoop.hdds.scm.node.NodeStatus; import org.apache.hadoop.hdds.scm.pipeline.Pipeline; import org.apache.hadoop.hdds.scm.pipeline.PipelineManager; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.OzoneStorageContainerManager; import org.apache.hadoop.hdds.upgrade.HDDSLayoutVersionManager; import org.apache.hadoop.hdds.utils.db.Table; @@ -194,7 +194,7 @@ public class TestEndpoints extends AbstractReconSqlDBTest { private static final String PROMETHEUS_TEST_RESPONSE_FILE = "prometheus-test-response.txt"; private ReconUtils reconUtilsMock; - private StorageContainerLocationProtocol mockScmClient; + private StorageContainerLocationInternalInterface mockScmClient; private List nodes = getNodeDetails(2); private Map> containerOnDecom = getContainersOnDecomNodes(); @@ -237,7 +237,7 @@ private void initializeInjector() throws Exception { new ContainerWithPipeline(containerInfo, pipeline); mockScmClient = mock( - StorageContainerLocationProtocol.class, Mockito.RETURNS_DEEP_STUBS); + StorageContainerLocationInternalInterface.class, Mockito.RETURNS_DEEP_STUBS); StorageContainerServiceProvider mockScmServiceProvider = mock( StorageContainerServiceProviderImpl.class); when(mockScmServiceProvider.getPipeline( @@ -284,7 +284,7 @@ private void initializeInjector() throws Exception { .addBinding(ContainerHealthSchemaManager.class) .addBinding(UtilizationEndpoint.class) .addBinding(ReconUtils.class, reconUtilsMock) - .addBinding(StorageContainerLocationProtocol.class, mockScmClient) + .addBinding(StorageContainerLocationInternalInterface.class, mockScmClient) .build(); reconScm = (ReconStorageContainerManagerFacade) diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestOpenContainerCount.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestOpenContainerCount.java index e4325f9604fb..9ab383129133 100644 --- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestOpenContainerCount.java +++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestOpenContainerCount.java @@ -62,7 +62,7 @@ import org.apache.hadoop.hdds.scm.container.common.helpers.ContainerWithPipeline; import org.apache.hadoop.hdds.scm.pipeline.Pipeline; import org.apache.hadoop.hdds.scm.pipeline.PipelineManager; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.OzoneStorageContainerManager; import org.apache.hadoop.hdfs.web.URLConnectionFactory; import org.apache.hadoop.ozone.OzoneConsts; @@ -126,8 +126,8 @@ private void initializeInjector() throws Exception { pipeline2 = getRandomPipeline(datanodeDetails); pipelineId2 = pipeline2.getId().getId().toString(); - StorageContainerLocationProtocol mockScmClient = mock( - StorageContainerLocationProtocol.class); + StorageContainerLocationInternalInterface mockScmClient = mock( + StorageContainerLocationInternalInterface.class); mockScmServiceProvider = mock( StorageContainerServiceProviderImpl.class); @@ -205,7 +205,7 @@ private void initializeInjector() throws Exception { .addBinding(NodeEndpoint.class) .addBinding(MetricsServiceProviderFactory.class) .addBinding(ReconUtils.class, reconUtilsMock) - .addBinding(StorageContainerLocationProtocol.class, + .addBinding(StorageContainerLocationInternalInterface.class, mockScmClient) .build(); diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestPendingDeletionEndpoint.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestPendingDeletionEndpoint.java index 8a1987758077..00f4a19d282a 100644 --- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestPendingDeletionEndpoint.java +++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestPendingDeletionEndpoint.java @@ -27,7 +27,7 @@ import java.util.Map; import javax.ws.rs.core.Response; import org.apache.hadoop.hdds.protocol.proto.HddsProtos; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.ozone.recon.api.types.DataNodeMetricsCompleteResponse; import org.apache.hadoop.ozone.recon.api.types.DataNodeMetricsProgressResponse; import org.apache.hadoop.ozone.recon.api.types.DatanodePendingDeletionMetrics; @@ -52,13 +52,13 @@ public class TestPendingDeletionEndpoint { private PendingDeletionEndpoint pendingDeletionEndpoint; private ReconGlobalMetricsService reconGlobalMetricsService; private DataNodeMetricsService dataNodeMetricsService; - private StorageContainerLocationProtocol scmClient; + private StorageContainerLocationInternalInterface scmClient; @BeforeEach public void setup() { reconGlobalMetricsService = mock(ReconGlobalMetricsService.class); dataNodeMetricsService = mock(DataNodeMetricsService.class); - scmClient = mock(StorageContainerLocationProtocol.class); + scmClient = mock(StorageContainerLocationInternalInterface.class); pendingDeletionEndpoint = new PendingDeletionEndpoint( reconGlobalMetricsService, dataNodeMetricsService, scmClient); } diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestTriggerDBSyncEndpoint.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestTriggerDBSyncEndpoint.java index 5ec99ee9b44a..7fbcf1d2831f 100644 --- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestTriggerDBSyncEndpoint.java +++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/api/TestTriggerDBSyncEndpoint.java @@ -40,7 +40,7 @@ import java.nio.file.Path; import javax.ws.rs.core.Response; import org.apache.hadoop.hdds.conf.OzoneConfiguration; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.server.OzoneStorageContainerManager; import org.apache.hadoop.hdds.utils.db.DBCheckpoint; import org.apache.hadoop.ozone.om.OMMetadataManager; @@ -146,8 +146,8 @@ reconUtilsMock, ozoneManagerProtocol, new ReconContext(configuration, reconUtils .addBinding(NodeEndpoint.class) .addBinding(MetricsServiceProviderFactory.class) .addBinding(ReconUtils.class, reconUtilsMock) - .addBinding(StorageContainerLocationProtocol.class, - mock(StorageContainerLocationProtocol.class)) + .addBinding(StorageContainerLocationInternalInterface.class, + mock(StorageContainerLocationInternalInterface.class)) .build(); } diff --git a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/spi/impl/TestStorageContainerServiceProviderImpl.java b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/spi/impl/TestStorageContainerServiceProviderImpl.java index 6bf88bc216cc..69ea7aa6a36b 100644 --- a/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/spi/impl/TestStorageContainerServiceProviderImpl.java +++ b/hadoop-ozone/recon/src/test/java/org/apache/hadoop/ozone/recon/spi/impl/TestStorageContainerServiceProviderImpl.java @@ -34,7 +34,7 @@ import org.apache.hadoop.hdds.protocol.proto.HddsProtos; import org.apache.hadoop.hdds.scm.pipeline.Pipeline; import org.apache.hadoop.hdds.scm.pipeline.PipelineID; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.ozone.recon.ReconUtils; import org.apache.hadoop.ozone.recon.spi.StorageContainerServiceProvider; import org.junit.jupiter.api.BeforeEach; @@ -55,15 +55,15 @@ void setup(@TempDir File testDir) { @Override protected void configure() { try { - StorageContainerLocationProtocol mockScmClient = mock( - StorageContainerLocationProtocol.class); + StorageContainerLocationInternalInterface mockScmClient = mock( + StorageContainerLocationInternalInterface.class); ReconUtils reconUtils = new ReconUtils(); OzoneConfiguration conf = new OzoneConfiguration(); conf.set(HddsConfigKeys.OZONE_METADATA_DIRS, testDir.getPath()); pipelineID = PipelineID.randomId().getProtobuf(); when(mockScmClient.getPipeline(pipelineID)) .thenReturn(mock(Pipeline.class)); - bind(StorageContainerLocationProtocol.class) + bind(StorageContainerLocationInternalInterface.class) .toInstance(mockScmClient); bind(StorageContainerServiceProvider.class) .to(StorageContainerServiceProviderImpl.class); @@ -81,8 +81,8 @@ protected void configure() { public void testGetPipelines() throws IOException { StorageContainerServiceProvider scmProvider = injector.getInstance(StorageContainerServiceProvider.class); - StorageContainerLocationProtocol scmClient = - injector.getInstance(StorageContainerLocationProtocol.class); + StorageContainerLocationInternalInterface scmClient = + injector.getInstance(StorageContainerLocationInternalInterface.class); scmProvider.getPipelines(); verify(scmClient, times(1)).listPipelines(); } @@ -91,8 +91,8 @@ public void testGetPipelines() throws IOException { public void testGetPipeline() throws IOException { StorageContainerServiceProvider scmProvider = injector.getInstance(StorageContainerServiceProvider.class); - StorageContainerLocationProtocol scmClient = - injector.getInstance(StorageContainerLocationProtocol.class); + StorageContainerLocationInternalInterface scmClient = + injector.getInstance(StorageContainerLocationInternalInterface.class); Pipeline pipeline = scmProvider.getPipeline(pipelineID); assertNotNull(pipeline); verify(scmClient, times(1)) diff --git a/hadoop-ozone/vapor/src/main/java/org/apache/hadoop/ozone/freon/DatanodeSimulator.java b/hadoop-ozone/vapor/src/main/java/org/apache/hadoop/ozone/freon/DatanodeSimulator.java index 3a42d57a01dc..242fba5dd197 100644 --- a/hadoop-ozone/vapor/src/main/java/org/apache/hadoop/ozone/freon/DatanodeSimulator.java +++ b/hadoop-ozone/vapor/src/main/java/org/apache/hadoop/ozone/freon/DatanodeSimulator.java @@ -68,7 +68,7 @@ import org.apache.hadoop.hdds.protocol.proto.StorageContainerDatanodeProtocolProtos.SCMRegisteredResponseProto; import org.apache.hadoop.hdds.scm.container.common.helpers.ContainerWithPipeline; import org.apache.hadoop.hdds.scm.net.HostAndPort; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.server.JsonUtils; import org.apache.hadoop.hdds.server.ServerUtils; import org.apache.hadoop.hdds.upgrade.HDDSLayoutVersionManager; @@ -165,7 +165,7 @@ public class DatanodeSimulator implements Callable, VaporSubcommand { private AtomicLong totalHeartbeats = new AtomicLong(0); private AtomicLong totalFCRs = new AtomicLong(0); private AtomicLong totalICRs = new AtomicLong(0); - private StorageContainerLocationProtocol scmContainerClient; + private StorageContainerLocationInternalInterface scmContainerClient; @Override public Void call() throws Exception { diff --git a/hadoop-ozone/vapor/src/main/java/org/apache/hadoop/ozone/freon/SCMThroughputBenchmark.java b/hadoop-ozone/vapor/src/main/java/org/apache/hadoop/ozone/freon/SCMThroughputBenchmark.java index ca8fc7f6cbc0..e19fd3a9be8f 100644 --- a/hadoop-ozone/vapor/src/main/java/org/apache/hadoop/ozone/freon/SCMThroughputBenchmark.java +++ b/hadoop-ozone/vapor/src/main/java/org/apache/hadoop/ozone/freon/SCMThroughputBenchmark.java @@ -66,7 +66,7 @@ import org.apache.hadoop.hdds.scm.container.common.helpers.ExcludeList; import org.apache.hadoop.hdds.scm.pipeline.Pipeline; import org.apache.hadoop.hdds.scm.protocol.ScmBlockLocationProtocol; -import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationProtocol; +import org.apache.hadoop.hdds.scm.protocol.StorageContainerLocationInternalInterface; import org.apache.hadoop.hdds.scm.proxy.SCMClientConfig; import org.apache.hadoop.hdds.utils.HAUtils; import org.apache.hadoop.hdds.utils.LegacyHadoopConfigurationSource; @@ -174,7 +174,7 @@ public final class SCMThroughputBenchmark implements Callable, VaporSubcom private StorageContainerDatanodeProtocol datanodeScmClient; - private StorageContainerLocationProtocol scmContainerClient; + private StorageContainerLocationInternalInterface scmContainerClient; private ScmBlockLocationProtocol scmBlockClient; @@ -327,7 +327,7 @@ private StorageContainerDatanodeProtocol createDatanodeScmClient() return new StorageContainerDatanodeProtocolClientSideTranslatorPB(rpcProxy); } - private StorageContainerLocationProtocol createScmContainerClient() { + private StorageContainerLocationInternalInterface createScmContainerClient() { return HAUtils.getScmContainerClient(conf); }