import com.hazelcast.instance.Node; //导入依赖的package包/类
public TcpIpJoinerOverAWS(Node node) {
    super(node);
    logger = node.getLogger(getClass());

    AwsConfig awsConfig = node.getConfig().getNetworkConfig().getJoin().getAwsConfig();
    aws = new AWSClient(awsConfig);
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
protected boolean isInstanceNotActive(HazelcastInstance hz) {
    if (hz == null) {
        return true;
    }
    Node node = TestUtil.getNode(hz);
    return node == null || !node.isRunning();
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
public ConsulJoiner(final Node node, final ConsulConfig consulConfig) {
    super(node);
    this.consulConfig = consulConfig;
    
    // autoconnect to consul
    this.connect();
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
protected AbstractJetMessageTask(ClientMessage clientMessage, Node node, Connection connection,
                                 Function<ClientMessage, P> decoder, Function<Object, ClientMessage> encoder) {
    super(clientMessage, node, connection);

    this.decoder = decoder;
    this.encoder = encoder;
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
public static InternalOperationService getOperationService(HazelcastInstance hz) {
    Node node = checkNotNull(getNode(hz), "node is null in Hazelcast instance " + hz);
    NodeEngineImpl nodeEngine = node.getNodeEngine();
    try {
        return nodeEngine.getOperationService();
    } catch (NoSuchMethodError e) {
        // fallback for a binary incompatible change (see commit http://git.io/vtfKU)
        return getOperationServiceViaReflection(nodeEngine);
    }
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
private InternalPartitionServiceImpl getInternalPartitionService() {
    Node node = nodeEngine.getNode();
    return (InternalPartitionServiceImpl) node.getPartitionService();
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
protected JetCancelJobMessageTask(ClientMessage clientMessage, Node node, Connection connection) {
    super(clientMessage, node, connection, JetCancelJobCodec::decodeRequest,
            o -> JetCancelJobCodec.encodeResponse());
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
protected JetSubmitJobMessageTask(ClientMessage clientMessage, Node node, Connection connection) {
    super(clientMessage, node, connection, JetSubmitJobCodec::decodeRequest,
            o -> JetSubmitJobCodec.encodeResponse());
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
protected JetGetJobStatusMessageTask(ClientMessage clientMessage, Node node, Connection connection) {
    super(clientMessage, node, connection, JetGetJobStatusCodec::decodeRequest,
            o -> JetGetJobStatusCodec.encodeResponse((Data) o));
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
protected JetGetJobIdsMessageTask(ClientMessage clientMessage, Node node, Connection connection) {
    super(clientMessage, node, connection, JetGetJobIdsCodec::decodeRequest,
            o -> JetGetJobIdsCodec.encodeResponse((Data) o));
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
protected JetJoinSubmittedJobMessageTask(ClientMessage clientMessage, Node node, Connection connection) {
    super(clientMessage, node, connection, JetJoinSubmittedJobCodec::decodeRequest,
            o -> JetJoinSubmittedJobCodec.encodeResponse((Data) o));
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
protected JetGetJobSubmissionTimeMessageTask(ClientMessage clientMessage, Node node, Connection connection) {
    super(clientMessage, node, connection, JetGetJobSubmissionTimeCodec::decodeRequest,
            o -> JetGetJobSubmissionTimeCodec.encodeResponse((long) o));
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
protected JetGetJobConfigMessageTask(ClientMessage clientMessage, Node node, Connection connection) {
    super(clientMessage, node, connection, JetGetJobConfigCodec::decodeRequest,
            o -> JetGetJobConfigCodec.encodeResponse((Data) o));
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
protected JetGetJobIdsByNameMessageTask(ClientMessage clientMessage, Node node, Connection connection) {
    super(clientMessage, node, connection, JetGetJobIdsByNameCodec::decodeRequest,
            o -> JetGetJobIdsByNameCodec.encodeResponse((Data) o));
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
private static void unblacklistJoinerBetween(HazelcastInstance h1, HazelcastInstance h2) {
    Node h1Node = getNode(h1);
    Node h2Node = getNode(h2);
    h1Node.getJoiner().unblacklist(h2Node.getThisAddress());
    h2Node.getJoiner().unblacklist(h1Node.getThisAddress());
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
public static Node getNode(JetInstance instance) {
    return getNode(hz(instance));
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
AbstractSnowcastMessageTask(ClientMessage clientMessage, Node node, Connection connection) {
    super(clientMessage, node, connection);
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
DestroySequencerDefinitionMessageTask(ClientMessage clientMessage, Node node, Connection connection) {
    super(clientMessage, node, connection);
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
CreateSequencerDefinitionMessageTask(ClientMessage clientMessage, Node node, Connection connection) {
    super(clientMessage, node, connection);
}
 

import com.hazelcast.instance.Node; //导入依赖的package包/类
RemoveChannelMessageTask(ClientMessage clientMessage, Node node, Connection connection) {
    super(clientMessage, node, connection);
}