Examples with VersionedDataOutputStream org.apache.geode.internal.VersionedDataOutputStream used on opensource projects

Example 1 with VersionedDataOutputStream

use of org.apache.geode.internal.VersionedDataOutputStream in project geode by apache.

the class TcpClient method getServerVersion.

private Short getServerVersion(InetSocketAddress ipAddr, int timeout) throws IOException, ClassNotFoundException {
    int gossipVersion = TcpServer.getCurrentGossipVersion();
    Short serverVersion = null;
    // Get GemFire version of TcpServer first, before sending any other request.
    synchronized (serverVersions) {
        serverVersion = serverVersions.get(ipAddr);
    }
    if (serverVersion != null) {
        return serverVersion;
    }
    gossipVersion = TcpServer.getOldGossipVersion();
    Socket sock = null;
    try {
        sock = socketCreator.connect(ipAddr.getAddress(), ipAddr.getPort(), timeout, null, false);
        sock.setSoTimeout(timeout);
    } catch (SSLException e) {
        throw new LocatorCancelException("Unable to form SSL connection", e);
    }
    try {
        DataOutputStream out = new DataOutputStream(sock.getOutputStream());
        out = new VersionedDataOutputStream(out, Version.GFE_57);
        out.writeInt(gossipVersion);
        VersionRequest verRequest = new VersionRequest();
        DataSerializer.writeObject(verRequest, out);
        out.flush();
        InputStream inputStream = sock.getInputStream();
        DataInputStream in = new DataInputStream(inputStream);
        in = new VersionedDataInputStream(in, Version.GFE_57);
        try {
            Object readObject = DataSerializer.readObject(in);
            if (!(readObject instanceof VersionResponse)) {
                throw new LocatorCancelException("Unrecognisable response received: object is null. This could be the result of trying to connect a non-SSL-enabled locator to an SSL-enabled locator.");
            }
            VersionResponse response = (VersionResponse) readObject;
            if (response != null) {
                serverVersion = Short.valueOf(response.getVersionOrdinal());
                synchronized (serverVersions) {
                    serverVersions.put(ipAddr, serverVersion);
                }
                return serverVersion;
            }
        } catch (EOFException ex) {
        // old locators will not recognize the version request and will close the connection
        }
    } finally {
        try {
            // initiate an abort on close to shut down the server's socket
            sock.setSoLinger(true, 0);
            sock.close();
        } catch (Exception e) {
            logger.error("Error closing socket ", e);
        }
    }
    if (logger.isDebugEnabled()) {
        logger.debug("Locator " + ipAddr + " did not respond to a request for its version.  I will assume it is using v5.7 for safety.");
    }
    synchronized (serverVersions) {
        serverVersions.put(ipAddr, Version.GFE_57.ordinal());
    }
    return Short.valueOf(Version.GFE_57.ordinal());
}

Example 2 with VersionedDataOutputStream

use of org.apache.geode.internal.VersionedDataOutputStream in project geode by apache.

the class HandShake method write.

/**
   * client-to-server handshake. Nothing is sent to the server prior to invoking this method.
   */
private byte write(DataOutputStream dos, DataInputStream dis, byte communicationMode, int replyCode, int readTimeout, List ports, Properties p_credentials, DistributedMember member, boolean isCallbackConnection) throws IOException {
    HeapDataOutputStream hdos = new HeapDataOutputStream(32, Version.CURRENT);
    byte acceptanceCode = -1;
    try {
        hdos.writeByte(communicationMode);
        if (overrideClientVersion > 0) {
            // for testing
            Version.writeOrdinal(hdos, overrideClientVersion, true);
        } else {
            Version.writeOrdinal(hdos, currentClientVersion.ordinal(), true);
        }
        hdos.writeByte(replyCode);
        if (ports != null) {
            hdos.writeInt(ports.size());
            for (int i = 0; i < ports.size(); i++) {
                hdos.writeInt(Integer.parseInt((String) ports.get(i)));
            }
        } else {
            hdos.writeInt(readTimeout);
        }
        // we do not know the receiver's version at this point, but the on-wire
        // form of InternalDistributedMember changed in 9.0, so we must serialize
        // it using the previous version
        DataOutput idOut = new VersionedDataOutputStream(hdos, Version.GFE_82);
        DataSerializer.writeObject(this.id, idOut);
        if (currentClientVersion.compareTo(Version.GFE_603) >= 0) {
            for (int bytes = 0; bytes < this.overrides.length; bytes++) {
                hdos.writeByte(this.overrides[bytes]);
            }
        } else {
            // write the client conflation setting byte
            if (setClientConflationForTesting) {
                hdos.writeByte(clientConflationForTesting);
            } else {
                hdos.writeByte(this.clientConflation);
            }
        }
        if (isCallbackConnection || communicationMode == Acceptor.GATEWAY_TO_GATEWAY) {
            if (isCallbackConnection && this.multiuserSecureMode && communicationMode != Acceptor.GATEWAY_TO_GATEWAY) {
                hdos.writeByte(SECURITY_MULTIUSER_NOTIFICATIONCHANNEL);
                hdos.flush();
                dos.write(hdos.toByteArray());
                dos.flush();
            } else {
                writeCredentials(dos, dis, p_credentials, ports != null, member, hdos);
            }
        } else {
            String authInitMethod = this.system.getProperties().getProperty(SECURITY_CLIENT_AUTH_INIT);
            acceptanceCode = writeCredential(dos, dis, authInitMethod, ports != null, member, hdos);
        }
    } finally {
        hdos.close();
    }
    return acceptanceCode;
}

Example 3 with VersionedDataOutputStream

use of org.apache.geode.internal.VersionedDataOutputStream in project geode by apache.

the class CacheClientNotifier method registerClient.

/**
   * Registers a new client updater that wants to receive updates with this server.
   *
   * @param socket The socket over which the server communicates with the client.
   */
public void registerClient(Socket socket, boolean isPrimary, long acceptorId, boolean notifyBySubscription) throws IOException {
    // Since no remote ports were specified in the message, wait for them.
    long startTime = this.statistics.startTime();
    DataInputStream dis = new DataInputStream(socket.getInputStream());
    DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
    // Read the client version
    short clientVersionOrdinal = Version.readOrdinal(dis);
    Version clientVersion = null;
    try {
        clientVersion = Version.fromOrdinal(clientVersionOrdinal, true);
        if (logger.isDebugEnabled()) {
            logger.debug("{}: Registering client with version: {}", this, clientVersion);
        }
    } catch (UnsupportedVersionException e) {
        SocketAddress sa = socket.getRemoteSocketAddress();
        UnsupportedVersionException uve = e;
        if (sa != null) {
            String sInfo = " Client: " + sa.toString() + ".";
            uve = new UnsupportedVersionException(e.getMessage() + sInfo);
        }
        logger.warn(LocalizedMessage.create(LocalizedStrings.CacheClientNotifier_CACHECLIENTNOTIFIER_CAUGHT_EXCEPTION_ATTEMPTING_TO_CLIENT), uve);
        writeException(dos, Acceptor.UNSUCCESSFUL_SERVER_TO_CLIENT, uve, clientVersion);
        return;
    }
    // Read and ignore the reply code. This is used on the client to server
    // handshake.
    // replyCode
    dis.readByte();
    if (Version.GFE_57.compareTo(clientVersion) <= 0) {
        if (Version.CURRENT.compareTo(clientVersion) > 0) {
            dis = new VersionedDataInputStream(dis, clientVersion);
            dos = new VersionedDataOutputStream(dos, clientVersion);
        }
        registerGFEClient(dis, dos, socket, isPrimary, startTime, clientVersion, acceptorId, notifyBySubscription);
    } else {
        Exception e = new UnsupportedVersionException(clientVersionOrdinal);
        throw new IOException(e.toString());
    }
}

Example 4 with VersionedDataOutputStream

use of org.apache.geode.internal.VersionedDataOutputStream in project geode by apache.

the class OldClientSupportProvider method processOutgoingClassName.

@Override
public String processOutgoingClassName(String name, DataOutput out) {
    // tcpserver was moved to a different package
    String oldPackage = "com.gemstone.org.jgroups.stack.tcpserver";
    String newPackage = "org.apache.geode.distributed.internal.tcpserver";
    if (name.startsWith(newPackage)) {
        return oldPackage + name.substring(newPackage.length());
    }
    if (ALWAYS_CONVERT_CLASSES) {
        return processClassName(name, GEODE, GEMFIRE, newClassNamesToOld);
    }
    // if the client is old then it needs com.gemstone.gemfire package names
    if (out instanceof VersionedDataOutputStream) {
        VersionedDataOutputStream vout = (VersionedDataOutputStream) out;
        Version version = vout.getVersion();
        if (version != null && version.compareTo(Version.GFE_90) < 0) {
            return processClassName(name, GEODE, GEMFIRE, newClassNamesToOld);
        }
    }
    return name;
}

Example 5 with VersionedDataOutputStream

use of org.apache.geode.internal.VersionedDataOutputStream in project geode by apache.

the class HandShake method accept.

public void accept(OutputStream out, InputStream in, byte epType, int qSize, byte communicationMode, Principal principal) throws IOException {
    DataOutputStream dos = new DataOutputStream(out);
    DataInputStream dis;
    if (clientVersion.compareTo(Version.CURRENT) < 0) {
        dis = new VersionedDataInputStream(in, clientVersion);
        dos = new VersionedDataOutputStream(dos, clientVersion);
    } else {
        dis = new DataInputStream(in);
    }
    // Write ok reply
    if (communicationMode == Acceptor.GATEWAY_TO_GATEWAY && principal != null) {
        dos.writeByte(REPLY_WAN_CREDENTIALS);
    } else {
        // byte 59
        dos.writeByte(REPLY_OK);
    }
    // additional byte of wan site needs to send for Gateway BC
    if (communicationMode == Acceptor.GATEWAY_TO_GATEWAY) {
        Version.writeOrdinal(dos, ServerHandShakeProcessor.currentServerVersion.ordinal(), true);
    }
    dos.writeByte(epType);
    dos.writeInt(qSize);
    // Write the server's member
    DistributedMember member = this.system.getDistributedMember();
    ServerHandShakeProcessor.writeServerMember(member, dos);
    // Write no message
    dos.writeUTF("");
    // Write delta-propagation property value if this is not WAN.
    if (communicationMode != Acceptor.GATEWAY_TO_GATEWAY && this.clientVersion.compareTo(Version.GFE_61) >= 0) {
        dos.writeBoolean(((InternalDistributedSystem) this.system).getConfig().getDeltaPropagation());
    }
    // and principal not equal to null then send the credentials also
    if (communicationMode == Acceptor.GATEWAY_TO_GATEWAY && principal != null) {
        sendCredentialsForWan(dos, dis);
    }
    // on the remote side of the gateway
    if (communicationMode == Acceptor.GATEWAY_TO_GATEWAY && this.clientVersion.compareTo(Version.GFE_66) >= 0 && ServerHandShakeProcessor.currentServerVersion.compareTo(Version.GFE_66) >= 0) {
        dos.writeByte(((InternalDistributedSystem) this.system).getDistributionManager().getDistributedSystemId());
    }
    if ((communicationMode == Acceptor.GATEWAY_TO_GATEWAY) && this.clientVersion.compareTo(Version.GFE_80) >= 0 && ServerHandShakeProcessor.currentServerVersion.compareTo(Version.GFE_80) >= 0) {
        int pdxSize = PeerTypeRegistration.getPdxRegistrySize();
        dos.writeInt(pdxSize);
    }
    // Flush
    dos.flush();
}