Refactored eureka discovery to run in docker environment

Author: Nasruddin

docker/docker-compose.yml

@@ -4,7 +4,6 @@ services:
   course:
     build: ../microservices/course-service
     image: javatab/course_service:v1
-    container_name: course_service_v1
     mem_limit: 512m
     environment:
       - SPRING_PROFILES_ACTIVE=docker
@@ -15,7 +14,6 @@ services:
   search:
     build: ../microservices/search-service
     image: javatab/search_service:v1
-    container_name: search_service_v1
     mem_limit: 512m
     environment:
       - SPRING_PROFILES_ACTIVE=docker
@@ -26,7 +24,6 @@ services:
   student:
     build: ../microservices/student-service
     image: javatab/student_service:v1
-    container_name: student_service_v1
     mem_limit: 512m
     environment:
       - SPRING_PROFILES_ACTIVE=docker
@@ -37,7 +34,6 @@ services:
   vote:
     build: ../microservices/vote-service
     image: javatab/vote_service:v1
-    container_name: vote_service_v1
     mem_limit: 512m
     environment:
       - SPRING_PROFILES_ACTIVE=docker
@@ -48,7 +44,6 @@ services:
   course-composite:
     build: ../microservices/course-composite-service
     image: javatab/course_composite_service:v1
-    container_name: course_composite_service_v1
     mem_limit: 512m
     ports:
       - "8080:8080" # Only this service will be exposed to outside containers so no port binding for above images

microservices/course-composite-service/src/main/java/io/javatab/microservices/composite/course/CourseCompositeServiceApplication.java

@@ -1,14 +1,18 @@
 package io.javatab.microservices.composite.course;
 
 import io.javatab.microservices.composite.course.configuration.OpenApiConfigProperties;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.context.properties.EnableConfigurationProperties;
 import org.springframework.cloud.client.loadbalancer.LoadBalanced;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ComponentScan;
 import org.springframework.web.client.RestTemplate;
+import org.springframework.web.reactive.function.client.ExchangeFilterFunction;
 import org.springframework.web.reactive.function.client.WebClient;
+import reactor.core.publisher.Mono;
 
 @SpringBootApplication
 @ComponentScan("io.javatab")
@@ -19,10 +23,4 @@ public static void main(String[] args) {
 		SpringApplication.run(CourseCompositeServiceApplication.class, args);
 	}
 
-	@Bean
-	@LoadBalanced
-	public WebClient.Builder loadBalancedWebClientBuilder() {
-		return WebClient.builder();
-	}
-
 }

microservices/course-composite-service/src/main/java/io/javatab/microservices/composite/course/configuration/WebClients.java

@@ -0,0 +1,39 @@
+package io.javatab.microservices.composite.course.configuration;
+
+import io.netty.resolver.DefaultAddressResolverGroup;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.cloud.client.loadbalancer.LoadBalanced;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.http.client.reactive.ReactorClientHttpConnector;
+import org.springframework.web.reactive.function.client.ExchangeFilterFunction;
+import org.springframework.web.reactive.function.client.WebClient;
+import reactor.core.publisher.Mono;
+import reactor.netty.http.client.HttpClient;
+
+@Configuration
+public class WebClients {
+
+    private static final Logger logger = LoggerFactory.getLogger(WebClients.class);
+
+    @Bean
+    @LoadBalanced
+    public WebClient.Builder loadBalancedWebClientBuilder() {
+        //HttpClient httpClient = HttpClient.create().resolver(DefaultAddressResolverGroup.INSTANCE);
+        return WebClient.builder();
+                //.filter(logRequest())
+                //.clientConnector(new ReactorClientHttpConnector(httpClient))
+                //.build();
+    }
+
+
+    private static ExchangeFilterFunction logRequest() {
+        return ExchangeFilterFunction.ofRequestProcessor(clientRequest -> {
+            logger.info("Request: {} {} {}", clientRequest.method(), clientRequest.url(), clientRequest.body());
+            clientRequest.headers().forEach((name, values) -> values.forEach(value -> logger.info("{}={}", name, value)));
+            return Mono.just(clientRequest);
+        });
+    }
+
+}

microservices/course-composite-service/src/main/java/io/javatab/microservices/composite/course/service/CourseCompositeIntegration.java

@@ -7,15 +7,18 @@
 import io.javatab.microservices.api.core.student.StudentService;
 import io.javatab.microservices.api.core.vote.Vote;
 import io.javatab.microservices.api.core.vote.VoteService;
+import io.javatab.microservices.api.exceptions.InvalidInputException;
+import io.javatab.microservices.api.exceptions.NotFoundException;
+import io.javatab.microservices.util.http.HttpErrorInfo;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Component;
-import org.springframework.web.client.RestTemplate;
 import org.springframework.web.reactive.function.client.WebClient;
 import org.springframework.web.reactive.function.client.WebClientResponseException;
 import reactor.core.publisher.Mono;
 
+import java.io.IOException;
+
 import static java.util.logging.Level.FINE;
 
 @Component
@@ -31,31 +34,64 @@ public class CourseCompositeIntegration implements CourseService, StudentService
     private static final String VOTE_SERVICE_URL = "http://vote";
 
     public CourseCompositeIntegration(
-            WebClient.Builder webClientBuilder,
+            WebClient.Builder webClient,
             ObjectMapper objectMapper) {
-        this.webClient = webClientBuilder.build();
+        this.webClient = webClient.build();
         this.objectMapper = objectMapper;
     }
 
+    private String getErrorMessage(WebClientResponseException ex) {
+        try {
+            return objectMapper.readValue(ex.getResponseBodyAsString(), HttpErrorInfo.class).getMessage();
+        } catch (IOException ioex) {
+            return ex.getMessage();
+        }
+    }
+
+    private Throwable handleException(Throwable ex) {
+
+        if (!(ex instanceof WebClientResponseException)) {
+            LOG.warn("Got a unexpected error: {}, will rethrow it", ex.toString());
+            return ex;
+        }
+
+        WebClientResponseException wcre = (WebClientResponseException)ex;
 
+        switch (wcre.getStatusCode()) {
+
+            case NOT_FOUND:
+                return new NotFoundException(getErrorMessage(wcre));
+
+            case UNPROCESSABLE_ENTITY :
+                return new InvalidInputException(getErrorMessage(wcre));
+
+            default:
+                LOG.warn("Got an unexpected HTTP error: {}, will rethrow it", wcre.getStatusCode());
+                LOG.warn("Error body: {}", wcre.getResponseBodyAsString());
+                return ex;
+        }
+    }
     @Override
     public Mono<Course> getCourse(int courseId) {
         LOG.info("Fetching courses in Integration layer");
         var url = COURSE_SERVICE_URL + "/course/" + courseId;
-        return webClient.get().uri(url).retrieve().bodyToMono(Course.class).log(LOG.getName(), FINE);
+        return webClient.get().uri(url).retrieve().bodyToMono(Course.class).map(course -> {
+            System.out.println("Course" + course);
+            return new Course(1, "d", "f", "r", 2);
+        }).log(LOG.getName(), FINE).onErrorMap(WebClientResponseException.class, this::handleException);
     }
 
     @Override
     public Mono<Student> getStudent(String studentId) {
         LOG.info("Fetching students in Integration layer");
         var url = STUDENT_SERVICE_URL + "/student/" + studentId;
-        return webClient.get().uri(url).retrieve().bodyToMono(Student.class).log(LOG.getName(), FINE);
+        return webClient.get().uri(url).retrieve().bodyToMono(Student.class).log(LOG.getName(), FINE).onErrorMap(WebClientResponseException.class, this::handleException);
     }
 
     @Override
     public Mono<Vote> getVote(int courseId) {
         LOG.info("Fetching votes in Integration layer");
         var url = VOTE_SERVICE_URL + "/vote/" + courseId;
-        return webClient.get().uri(url).retrieve().bodyToMono(Vote.class).log(LOG.getName(), FINE);
+        return webClient.get().uri(url).retrieve().bodyToMono(Vote.class).log(LOG.getName(), FINE).onErrorMap(WebClientResponseException.class, this::handleException);
     }
 }

microservices/course-composite-service/src/main/java/io/javatab/microservices/composite/course/service/CourseCompositeServiceImpl.java

@@ -23,9 +23,9 @@ public CourseCompositeServiceImpl(final CourseCompositeIntegration integration,
     @Override
     public Mono<CourseAggregate> getCourse(int courseId) {
         // Call integration apis
-        integration.getCourse(1);
-        integration.getStudent("name");
-        integration.getVote(1);
+        integration.getCourse(1).subscribe(course -> System.out.println("Course " + course));
+        integration.getStudent("name").subscribe(course -> System.out.println("student " + course));
+        integration.getVote(1).subscribe(course -> System.out.println("vote " + course));
         return Mono.just(new CourseAggregate(1, 1, 3, 3,
                 List.of(new Student(1, "Student Name", "email", "password"))));
     }

microservices/course-composite-service/src/main/resources/application.yml

@@ -1,15 +1,11 @@
 server.port: 8016
 spring.application.name: course-composite
-app:
-  course-service:
-    host: localhost
-    port: 8012
-  student-service:
-    host: localhost
-    port: 8013
-  vote-service:
-    host: localhost
-    port: 8014
+
+springdoc:
+  swagger-ui.path: /openapi/swagger-ui.html
+  api-docs.path: /openapi/v3/api-docs
+  packagesToScan: io.javatab.microservices.composite.course
+  pathsToMatch: /**
 
 open-api:
   version: 1.0.0
@@ -58,13 +54,6 @@ open-api:
         422 - An **Unprocessable Entity** error will be returned
 
 
-
-springdoc:
-  swagger-ui.path: /openapi/swagger-ui.html
-  api-docs.path: /openapi/v3/api-docs
-  packagesToScan: io.javatab.microservices.composite.course
-  pathsToMatch: /**
-
 app.eureka-server: localhost
 
 eureka:
@@ -78,18 +67,5 @@ eureka:
     leaseExpirationDurationInSeconds: 5
 ---
 spring.config.activate.on-profile: docker
-
 server.port: 8080
-
-eureka.client.serviceUrl.defaultZone: http://eureka:8761/eureka/
-
-app:
-  course-service:
-    host: course
-    port: 8080
-  student-service:
-    host: student
-    port: 8080
-  vote-service:
-    host: vote
-    port: 8080
+app.eureka-server: eureka

microservices/course-service/src/main/resources/application.yml

@@ -1,4 +1,5 @@
 server.port: 8012
+spring.application.name: course
 logging:
   level:
     root: INFO
@@ -15,11 +16,9 @@ eureka:
   instance:
     leaseRenewalIntervalInSeconds: 5
     leaseExpirationDurationInSeconds: 5
-spring:
-  application:
-    name: course
+
 ---
 spring.config.activate.on-profile: docker
 server.port: 8080
-eureka.client.serviceUrl.defaultZone: http://eureka:8761/eureka/
+app.eureka-server: eureka
 spring.data.mongodb.host: mongodb

microservices/search-service/src/main/resources/application.yml

@@ -1,4 +1,5 @@
 server.port: 8015
+spring.application.name: search
 app.eureka-server: localhost
 
 eureka:
@@ -10,12 +11,10 @@ eureka:
   instance:
     leaseRenewalIntervalInSeconds: 5
     leaseExpirationDurationInSeconds: 5
-spring:
-  application:
-    name: search
+
 ---
 spring.config.activate.on-profile: docker
 server.port: 8080
-eureka.client.serviceUrl.defaultZone: http://eureka:8761/eureka/
+app.eureka-server: eureka
 spring.elasticsearch:
   uris: http://elasticsearch:9200

microservices/student-service/src/main/resources/application.yml

@@ -1,5 +1,7 @@
 server.port: 8013
 spring:
+  application:
+    name: student
   datasource:
     driver-class-name: org.postgresql.Driver
     username: user
@@ -9,8 +11,7 @@ spring:
     database-platform: org.hibernate.dialect.PostgreSQLDialect
     hibernate:
       ddl-auto: update
-  application:
-    name: student
+
 
 app.eureka-server: localhost
 
@@ -27,5 +28,5 @@ eureka:
 ---
 spring.config.activate.on-profile: docker
 server.port: 8080
-eureka.client.serviceUrl.defaultZone: http://eureka:8761/eureka/
+app.eureka-server: eureka
 spring.datasource.url: jdbc:postgresql://postgres:5432/test