src/main/java/net/pterodactylus/fcp/quelaton/DefaultFcpClient.java

   1 package net.pterodactylus.fcp.quelaton;
   2
   3 import java.io.IOException;
   4 import java.util.concurrent.ExecutionException;
   5 import java.util.concurrent.ExecutorService;
   6 import java.util.concurrent.Future;
   7 import java.util.concurrent.atomic.AtomicBoolean;
   8 import java.util.concurrent.atomic.AtomicReference;
   9 import java.util.function.Supplier;
  10
  11 import net.pterodactylus.fcp.ClientHello;
  12 import net.pterodactylus.fcp.CloseConnectionDuplicateClientName;
  13 import net.pterodactylus.fcp.FcpConnection;
  14 import net.pterodactylus.fcp.FcpKeyPair;
  15 import net.pterodactylus.fcp.GenerateSSK;
  16 import net.pterodactylus.fcp.NodeHello;
  17 import net.pterodactylus.fcp.SSKKeypair;
  18
  19 /**
  20  * Default {@link FcpClient} implementation.
  21  *
  22  * @author <a href="bombe@freenetproject.org">David ‘Bombe’ Roden</a>
  23  */
  24 public class DefaultFcpClient implements FcpClient {
  25
  26         private final ExecutorService threadPool;
  27         private final String hostname;
  28         private final int port;
  29         private final AtomicReference<FcpConnection> fcpConnection = new AtomicReference<>();
  30         private final Supplier<String> clientName;
  31         private final Supplier<String> expectedVersion;
  32
  33         public DefaultFcpClient(ExecutorService threadPool, String hostname, int port, Supplier<String> clientName,
  34                         Supplier<String> expectedVersion) {
  35                 this.threadPool = threadPool;
  36                 this.hostname = hostname;
  37                 this.port = port;
  38                 this.clientName = clientName;
  39                 this.expectedVersion = expectedVersion;
  40         }
  41
  42         private void connect() throws IOException {
  43                 if (fcpConnection.get() != null) {
  44                         return;
  45                 }
  46                 fcpConnection.compareAndSet(null, createConnection());
  47         }
  48
  49         private FcpConnection createConnection() throws IOException {
  50                 FcpConnection connection = new FcpConnection(hostname, port);
  51                 connection.connect();
  52                 AtomicReference<NodeHello> receivedNodeHello = new AtomicReference<>();
  53                 AtomicBoolean receivedClosed = new AtomicBoolean();
  54                 FcpReplySequence nodeHelloSequence = new FcpReplySequence(threadPool, connection);
  55                 nodeHelloSequence
  56                                 .handle(NodeHello.class)
  57                                 .with((nodeHello) -> receivedNodeHello.set(nodeHello));
  58                 nodeHelloSequence
  59                                 .handle(CloseConnectionDuplicateClientName.class)
  60                                 .with((closeConnection) -> receivedClosed.set(true));
  61                 nodeHelloSequence.waitFor(() -> receivedNodeHello.get() != null || receivedClosed.get());
  62                 ClientHello clientHello = new ClientHello(clientName.get(), expectedVersion.get());
  63                 try {
  64                         nodeHelloSequence.send(clientHello).get();
  65                 } catch (InterruptedException | ExecutionException e) {
  66                         connection.close();
  67                         throw new IOException(String.format("Could not connect to %s:%d.", hostname, port), e);
  68                 }
  69                 return connection;
  70         }
  71
  72         @Override
  73         public GenerateKeypairCommand generateKeypair() {
  74                 return new GenerateKeypairCommandImpl();
  75         }
  76
  77         private class GenerateKeypairCommandImpl implements GenerateKeypairCommand {
  78
  79                 @Override
  80                 public Future<FcpKeyPair> execute() {
  81                         return threadPool.submit(() -> {
  82                                 connect();
  83                                 GenerateSSK generateSSK = new GenerateSSK();
  84                                 AtomicReference<FcpKeyPair> keyPair = new AtomicReference<>();
  85                                 FcpReplySequence replySequence = new FcpReplySequence(threadPool, fcpConnection.get());
  86                                 replySequence.handle(SSKKeypair.class)
  87                                                 .with((message) -> keyPair.set(
  88                                                                 new FcpKeyPair(message.getRequestURI(), message.getInsertURI())));
  89                                 replySequence.waitFor(() -> keyPair.get() != null);
  90                                 replySequence.send(generateSSK).get();
  91                                 return keyPair.get();
  92                         });
  93                 }
  94
  95         }
  96
  97 }