Merge branch 'main' into GP-55_CreateViewResolverExercise

Author: tboychuk

1-0-networking-and-http/1-0-0-hello-network-socket/README.MD

@@ -0,0 +1,23 @@
+# <img src="https://raw.githubusercontent.com/bobocode-projects/resources/master/image/logo_transparent_background.png" height=50/>Hello Network Socket
+
+Learn **Sockets** – the essential part of Java networking 💪
+
+### Pre-conditions ❗
+
+* You're supposed to have a basic understanding of a computer networking
+
+### Objectives
+
+* **create a server socket** based on a given port ✅
+* **accept clients** on the server side ✅
+* **read data sent by clients** using `InputStream` ✅
+* **create a client socket** connected to the server based on the host and port ✅
+* **send data to the server** using cline socket `OutputStream` ✅
+* **experiment** with MessageBoard application that consists of a client and server apps ✅
+
+### Exercise overview 🇺🇦
+TDB
+
+---
+
+#### 🆕 First time here? – [See Introduction](https://github.com/bobocode-projects/java-fundamentals-course/tree/main/0-0-intro#introduction)

1-0-networking-and-http/1-0-0-hello-network-socket/pom.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>1-0-networking-and-http</artifactId>
+        <groupId>com.bobocode</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>1-0-0-hello-network-socket</artifactId>
+    <properties>
+        <maven.compiler.source>11</maven.compiler.source>
+        <maven.compiler.target>11</maven.compiler.target>
+    </properties>
+    
+
+</project>

1-0-networking-and-http/1-0-0-hello-network-socket/src/main/java/com/bobocode/net/client/ClientUtil.java

@@ -0,0 +1,67 @@
+package com.bobocode.net.client;
+
+import com.bobocode.util.ExerciseNotCompletedException;
+import lombok.SneakyThrows;
+
+import java.io.*;
+import java.net.Socket;
+
+/**
+ * A util class that implements all the logic required for building {@link MessageBoardClient}.
+ */
+public class ClientUtil {
+    private ClientUtil() {
+    }
+
+    /**
+     * Using provided host and port it creates an instance of a new {@link Socket} using two-argument constructor.
+     * This means that returned socket will be already connected to the server, or will throw an error if the connection
+     * failed.
+     *
+     * @param host server host
+     * @param port server port
+     * @return an instance of a connected socket
+     */
+    @SneakyThrows
+    public static Socket openSocket(String host, int port) {
+        throw new ExerciseNotCompletedException(); // todo: implement according to javadoc and verify by ClientUtilTest
+    }
+
+    /**
+     * Creates a simple {@link BufferedReader} that allows to read messages from the console.
+     *
+     * @return console-based {@link BufferedReader}
+     */
+    @SneakyThrows
+    public static BufferedReader openConsoleReader() {
+        InputStreamReader consoleInputStream = new InputStreamReader(System.in);
+        return new BufferedReader(consoleInputStream);
+    }
+
+    /**
+     * Prints a prompt and reads a line using provided reader.
+     *
+     * @param reader
+     * @return the message read by reader
+     */
+    @SneakyThrows
+    public static String readMessage(BufferedReader reader) {
+        System.out.print("Enter message (q to quit): ");
+        return reader.readLine();
+    }
+
+    /**
+     * This is the most important method of this class. It allows writing a string message to the given socket.
+     * In order to write to the connected socket, it uses its {@link OutputStream}. But since we need to write text
+     * messages, it creates a {@link BufferedWriter} based on the {@link OutputStream}. A writer allows to
+     * write {@link String} messages instead of bytes. In order to force sending data to the remote socket,
+     * it flushed the buffer of the writer using a corresponding method.
+     *
+     * @param message a message that should be sent to the socket
+     * @param socket  a socket instance connected to the server
+     */
+    @SneakyThrows
+    public static void writeToSocket(String message, Socket socket) {
+        throw new ExerciseNotCompletedException(); // todo: implement according to javadoc and verify by ClientUtilTest
+    }
+}

1-0-networking-and-http/1-0-0-hello-network-socket/src/main/java/com/bobocode/net/client/MessageBoardClient.java

@@ -0,0 +1,40 @@
+package com.bobocode.net.client;
+
+import com.bobocode.net.server.MessageBoardServer;
+import lombok.SneakyThrows;
+
+import java.io.BufferedReader;
+import java.net.Socket;
+
+import static com.bobocode.net.client.ClientUtil.*;
+
+/**
+ * {@link MessageBoardClient} is a client app that allows connecting to the {@link MessageBoardServer} in order to send
+ * a message. This app reads a message from the console, connects to the server socket and sends a message writing
+ * data to the output stream. The message then will be printed on the {@link MessageBoardServer} side. The app will
+ * ask user to type message infinitely, until the user enters `q`.
+ * <p>
+ * PLEASE MAKE SURE THAT {@link MessageBoardServer} is running before using the client app.
+ * <p>
+ * If you have another machine, you can try to run {@link MessageBoardServer} on that machine. In order to do that, you
+ * need to make sure that you can find that machine by IP address, and the port you want to use is exposed properly.
+ * If so, you will need to specify corresponding HOST and POST values below.
+ */
+public class MessageBoardClient {
+    private static final String SERVER_ADDRESS = MessageBoardServer.HOST;
+    private static final int SERVER_PORT = MessageBoardServer.PORT;
+
+    @SneakyThrows
+    public static void main(String[] args) {
+        try (BufferedReader reader = openConsoleReader()) {
+            String message = readMessage(reader);
+
+            while (!message.equals("q")) {
+                try (Socket socket = openSocket(SERVER_ADDRESS, SERVER_PORT)) {
+                    writeToSocket(message, socket);
+                }
+                message = readMessage(reader);
+            }
+        }
+    }
+}

1-0-networking-and-http/1-0-0-hello-network-socket/src/main/java/com/bobocode/net/server/MessageBoardServer.java

@@ -0,0 +1,31 @@
+package com.bobocode.net.server;
+
+import java.io.IOException;
+import java.net.ServerSocket;
+import java.net.Socket;
+
+import static com.bobocode.net.server.ServerUtil.*;
+
+/**
+ * {@link MessageBoardServer} is a server application that allows clients to connect via socket and print a message.
+ * It opens a server socket on a given port and waits for a client to connect using a infinite loop. Once client is
+ * connected this app reads a message from the connected socket input stream and prints it to the console.
+ * <p>
+ * It uses only one thread. So if multiple clients will try to connect at the same time, they will be waiting and will
+ * be processed one by one.
+ */
+public class MessageBoardServer {
+    public static final String HOST = ServerUtil.getLocalHost();
+    public static final int PORT = 8899; // you can use any free port you want
+
+    public static void main(String[] args) throws IOException {
+        try (ServerSocket serverSocket = createServerSocket(PORT)) {
+            while (true) {
+                try (Socket clientSocket = acceptClientSocket(serverSocket)) {
+                    String message = readMessageFromSocket(clientSocket);
+                    printMessage(clientSocket, message);
+                }
+            }
+        }
+    }
+}

1-0-networking-and-http/1-0-0-hello-network-socket/src/main/java/com/bobocode/net/server/ServerUtil.java

@@ -0,0 +1,86 @@
+package com.bobocode.net.server;
+
+import com.bobocode.util.ExerciseNotCompletedException;
+import lombok.SneakyThrows;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.InetAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+
+/**
+ * Util class for a {@link MessageBoardServer}. It provides all necessary method for network communication. Using these
+ * utils you can create server socket, accept connection from client, read String message from client socket and print
+ * it using special provided format.
+ */
+public class ServerUtil {
+    private static final DateTimeFormatter TIME_FORMATTER = DateTimeFormatter.ofPattern("HH:mm:ss");
+
+    private ServerUtil() {
+    }
+
+    /**
+     * A simple method that returns localhost
+     *
+     * @return localhost address
+     */
+    @SneakyThrows
+    public static String getLocalHost() {
+        return InetAddress.getLocalHost().getHostAddress();
+    }
+
+    /**
+     * Creates an instance of a {@link ServerSocket} based on the given port.
+     *
+     * @param port
+     * @return a new bound {@link ServerSocket} instance
+     */
+    @SneakyThrows
+    public static ServerSocket createServerSocket(int port) {
+        throw new ExerciseNotCompletedException(); // todo: implement according to javadoc and verify by ServerUtilTest
+    }
+
+    /**
+     * This method accepts a client on a given serverSocket and returns a accepted socket instance.
+     *
+     * @param serverSocket an open server socket
+     * @return an instance of a accepted client socket
+     */
+    @SneakyThrows
+    public static Socket acceptClientSocket(ServerSocket serverSocket) {
+        throw new ExerciseNotCompletedException(); // todo: implement according to javadoc and verify by ServerUtilTest
+    }
+
+    /**
+     * This is the most important method of this class. It allows reading all messages sent by client form the sockets.
+     * In order to read from a socket, it uses its {@link InputStream}. But since we want to read {@link String}
+     * messages instead of bytes, it creates a {@link BufferedReader} based on the socket {@link InputStream}.
+     * Using the reader, it reads a line and returns a {@link String} message.
+     *
+     * @param socket an accepted socket
+     * @return message that was received from the client
+     */
+    @SneakyThrows
+    public static String readMessageFromSocket(Socket socket) {
+        throw new ExerciseNotCompletedException(); // todo: implement according to javadoc and verify by ServerUtilTest
+    }
+
+    /**
+     * Simple message that allows to print message using a nice and informative format. Apart from the text message
+     * itself, it also prints the time and client address.
+     *
+     * @param socket  accepted socket
+     * @param message a text message to print
+     */
+    public static void printMessage(Socket socket, String message) {
+        InetAddress clientAddress = socket.getInetAddress();
+        System.out.print(LocalDateTime.now().format(TIME_FORMATTER) + " ");
+        System.out.printf("[%s]", clientAddress.getHostAddress());
+        System.out.println(" -- " + message);
+    }
+
+}

1-0-networking-and-http/1-0-0-hello-network-socket/src/test/java/com/bobocode/net/client/ClientUtilTest.java

@@ -0,0 +1,99 @@
+package com.bobocode.net.client;
+
+import lombok.SneakyThrows;
+import org.junit.jupiter.api.*;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.net.InetAddress;
+import java.net.InetSocketAddress;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.concurrent.CompletableFuture;
+
+import static com.bobocode.net.client.ClientUtil.openSocket;
+import static com.bobocode.net.client.ClientUtil.writeToSocket;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+
+@TestMethodOrder(MethodOrderer.OrderAnnotation.class)
+class ClientUtilTest {
+    @BeforeEach
+    public void init() {
+    }
+
+    @Order(1)
+    @ParameterizedTest
+    @ValueSource(ints = {8899, 9988})
+    @DisplayName("openSocket creates an instance of Socket based on given host and port")
+    @SneakyThrows
+    void openSocketCreatesSocketConnectedToServer(int port) {
+        try (var serverSocket = new ServerSocket(port);
+             var clientSocket = openSocket(serverSocket.getInetAddress().getHostAddress(), port)) {
+
+            assertNotNull(clientSocket);
+            assertThat(clientSocket.getClass()).isEqualTo(Socket.class);
+            assertThat(clientSocket.getPort()).isEqualTo(port);
+            InetAddress remoteSocketAddress = ((InetSocketAddress) clientSocket.getRemoteSocketAddress()).getAddress();
+            assertThat(remoteSocketAddress).isEqualTo(InetAddress.getLocalHost());
+        }
+    }
+
+    @Order(2)
+    @Test
+    @DisplayName("openSocket returns socket that is bound")
+    @SneakyThrows
+    void openSocketReturnsBoundSocket() {
+        int port = 8899;
+        try (var serverSocket = new ServerSocket(port);
+             var clientSocket = openSocket(serverSocket.getInetAddress().getHostAddress(), port)) {
+
+            assertTrue(clientSocket.isBound());
+        }
+    }
+
+    @Order(3)
+    @Test
+    @DisplayName("openSocket returns socket that is connected")
+    @SneakyThrows
+    void openSocketReturnsNotClosedSocket() {
+        int port = 8899;
+        try (var serverSocket = new ServerSocket(port);
+             var clientSocket = openSocket(serverSocket.getInetAddress().getHostAddress(), port)) {
+
+            assertTrue(clientSocket.isConnected());
+        }
+    }
+
+    @Order(4)
+    @ParameterizedTest
+    @ValueSource(strings = {"bye-bye", "see ya"})
+    @DisplayName("writeToSocket sends given messages to server via socket output stream")
+    @SneakyThrows
+    void writeToSocketSendsMessageViaOutputStream(String givenMessage) {
+        int port = 8899;
+        try (var serverSocket = new ServerSocket(port)) {
+            CompletableFuture<String> receivedMessageFuture = CompletableFuture.supplyAsync(() -> readMessage(serverSocket));
+            try (var clientSocket = new Socket(InetAddress.getLocalHost().getHostAddress(), port)) {
+
+                writeToSocket(givenMessage, clientSocket);
+
+            }
+            assertThat(receivedMessageFuture.get()).isEqualTo(givenMessage);
+        }
+    }
+
+    @SneakyThrows
+    private String readMessage(ServerSocket serverSocket) {
+        try (var clientSocket = serverSocket.accept()) {
+            InputStream inputStream = clientSocket.getInputStream();
+            BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
+            return reader.readLine();
+        }
+    }
+}