createSequence() {
6 | return Flux.error(new ToDoException());
7 | }
8 |
9 | static class State {
10 |
11 | final State previous;
12 | final long value;
13 | final long iteration;
14 |
15 | State(long iteration, long value, State previous) {
16 | this.iteration = iteration;
17 | this.previous = previous;
18 | this.value = value;
19 | }
20 | }
21 |
22 | static final State STATE_INITIAL = new State(1, 1, new State(0, 0, null));
23 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/FibonacciSequence/task.md:
--------------------------------------------------------------------------------
1 | Create `Flux` that ***generates*** a [Fibonacci sequence](https://en.wikipedia.org/wiki/Fibonacci_number) with 20 iterations depth
2 |
3 |
4 | Use Flux.generate(stateSupplier, (state, sink) -> state).
5 | Consider to use и Flux#startWith in order to supply the very first element of the Fibonacci sequence
6 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/FibonacciSequence/task.ru.md:
--------------------------------------------------------------------------------
1 | Сгенерируйте `Flux` последовательности фибоначи глубиной в 20
2 |
3 |
4 | Используйте Flux.generate(stateSupplier, (state, sink) -> state) и .startWith для передачи [0] последовательности
5 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/GenerateUUID/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor:reactor-core'
3 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/GenerateUUID/src/GenerateUUIDTask.java:
--------------------------------------------------------------------------------
1 | import reactor.core.publisher.Mono;
2 |
3 | public class GenerateUUIDTask {
4 |
5 | static UUIDGenerator uuidGenerator;
6 |
7 | public static String generateRandomUUID() {
8 | return uuidGenerator.secureUUID();
9 | }
10 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/GenerateUUID/src/UUIDGenerator.java:
--------------------------------------------------------------------------------
1 | public interface UUIDGenerator {
2 | String secureUUID();
3 | }
4 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/GenerateUUID/task.md:
--------------------------------------------------------------------------------
1 | Refactor given code to reactive in the best way
2 |
3 |
4 | Use Mono.just(element) with Mono.defer or Mono.fromSupplier
5 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/HandleGetRequest/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor:reactor-core'
3 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/HandleGetRequest/src/HandleGetRequestTask.java:
--------------------------------------------------------------------------------
1 | import reactor.core.publisher.Mono;
2 |
3 | public class HandleGetRequestTask {
4 |
5 | public static final IllegalArgumentException UNSUPPORTED_HTTP_METHOD =
6 | new IllegalArgumentException("Unsupported HTTP method. Expected method GET");
7 |
8 | public static ReactiveRandom reactiveRandom;
9 |
10 | public static int getRandomNumberHandler(RequestEntity request) {
11 | if (request.method != HttpMethod.GET) {
12 | throw UNSUPPORTED_HTTP_METHOD;
13 | }
14 |
15 | return reactiveRandom.nextInt().block();
16 | }
17 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/HandleGetRequest/src/HttpMethod.java:
--------------------------------------------------------------------------------
1 | public enum HttpMethod {
2 | GET, POST, PUT, DELETE, HEAD, PATCH, TRACE, OPTIONS, CONNECT
3 | }
4 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/HandleGetRequest/src/ReactiveRandom.java:
--------------------------------------------------------------------------------
1 | import reactor.core.publisher.Mono;
2 |
3 | import java.security.SecureRandom;
4 |
5 | public class ReactiveRandom {
6 | public Mono nextInt() {
7 | return Mono.fromCallable(() -> SecureRandom.getInstanceStrong().nextInt());
8 | }
9 | }
10 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/HandleGetRequest/src/RequestEntity.java:
--------------------------------------------------------------------------------
1 | public class RequestEntity {
2 |
3 | final HttpMethod method;
4 | final T data;
5 |
6 | public RequestEntity(HttpMethod method, T data) {
7 | this.method = method;
8 | this.data = data;
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/HandleGetRequest/task.md:
--------------------------------------------------------------------------------
1 | Refactor given code to follow reactive principles (mainly non-blocking, async).
2 |
3 |
4 | Use Mono.just and Mono.error.
5 | Consider simple if-else instead of writing complex reactive pipe-line
6 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/PropertiesSource/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor:reactor-core'
3 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/PropertiesSource/src/Properties.java:
--------------------------------------------------------------------------------
1 | import java.util.List;
2 |
3 | public interface Properties {
4 | Property get(String key);
5 |
6 | List> asList();
7 | }
8 |
9 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/PropertiesSource/src/PropertiesSourceTask.java:
--------------------------------------------------------------------------------
1 | import reactor.core.publisher.Flux;
2 |
3 | public class PropertiesSourceTask {
4 |
5 | static Properties settings;
6 |
7 | public static Iterable> createSequence() {
8 | return settings.asList();
9 | }
10 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/PropertiesSource/src/Property.java:
--------------------------------------------------------------------------------
1 | public interface Property {
2 | String name();
3 |
4 | T value();
5 | }
6 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/PropertiesSource/task.md:
--------------------------------------------------------------------------------
1 | Generate a `Flux` from collection
2 |
3 |
4 | Use Flux.fromIterable
5 | ensure properties are interacted up on subscription
6 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/TextFileStream/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor:reactor-core'
3 | }
4 |
5 | sourceSets {
6 | main {
7 | java.srcDir 'src'
8 | resources.srcDir 'resources'
9 | }
10 | test {
11 | java.srcDir 'test'
12 | }
13 | }
14 |
15 | processResources {
16 | duplicatesStrategy = DuplicatesStrategy.EXCLUDE
17 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/TextFileStream/resources/testfile.txt:
--------------------------------------------------------------------------------
1 | handlers= java.util.logging.ConsoleHandler
2 | .level= DEBUG
3 | java.util.logging.ConsoleHandler.level = DEBUG
4 | java.util.logging.ConsoleHandler.formatter = java.util.logging.SimpleFormatter
5 | java.util.logging.SimpleFormatter.format=[%4$-5s] [%1$tT] %5$s %n
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/TextFileStream/src/TextFileStreamTask.java:
--------------------------------------------------------------------------------
1 | import java.io.IOException;
2 | import java.nio.file.Files;
3 | import java.nio.file.Paths;
4 | import java.util.stream.Collectors;
5 | import java.util.stream.Stream;
6 |
7 | import reactor.core.publisher.Flux;
8 |
9 | public class TextFileStreamTask {
10 |
11 | public static Iterable readFile(String filename) {
12 | try {
13 | return Files.lines(Paths.get(filename)).collect(Collectors.toList());
14 | } catch (IOException e) {
15 | throw new RuntimeException(e);
16 | }
17 | }
18 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/TextFileStream/task.md:
--------------------------------------------------------------------------------
1 | ***Using*** `Flux` API do the following:
2 |
3 | 1) Open File safely. Specific `Flux` API does not require extra exceptions handling
4 | 2) Read all the lines as `Flux`
5 | 3) Close opened resource on terminal operation
6 |
7 |
8 | Use Flux.using(Callable, Function, Consumer)
9 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/TextFileStream/test/TextFileStreamTests.java:
--------------------------------------------------------------------------------
1 | import java.net.URI;
2 | import java.net.URISyntaxException;
3 | import java.nio.file.Paths;
4 |
5 | import org.junit.jupiter.api.Assertions;
6 | import org.junit.jupiter.api.Test;
7 | import reactor.core.publisher.Flux;
8 | import reactor.test.StepVerifier;
9 |
10 | public class TextFileStreamTests {
11 |
12 | @Test
13 | public void testSolution() throws URISyntaxException {
14 | URI resourceUri = ClassLoader.getSystemResource("testfile.txt").toURI();
15 | Object source = TextFileStreamTask.readFile(Paths.get(resourceUri).toAbsolutePath().toString());
16 |
17 | if (!(source instanceof Flux)) {
18 | Assertions.fail("Unexpected return type");
19 | }
20 |
21 | StepVerifier.create(((Flux) source))
22 | .expectSubscription()
23 | .expectNextCount(5)
24 | .verifyComplete();
25 | }
26 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/ValidateDuration/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor:reactor-core'
3 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/ValidateDuration/src/ValidationTask.java:
--------------------------------------------------------------------------------
1 | import java.time.Duration;
2 |
3 | import reactor.core.publisher.Mono;
4 |
5 | public class ValidationTask {
6 |
7 | public static boolean validate(Duration duration) {
8 | return !duration.isNegative() && !duration.isZero();
9 | }
10 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/ValidateDuration/task.md:
--------------------------------------------------------------------------------
1 | Refactor the following validation into a reactive one
2 |
3 |
4 | Use Mono.empty() and Mono.error within if-else statement
5 |
--------------------------------------------------------------------------------
/Reactive Essentials/Sync Publishers/lesson-info.yaml:
--------------------------------------------------------------------------------
1 | custom_name: "Part 1: Sync Publishers"
2 | content:
3 | - CreateSequence
4 | - GenerateUUID
5 | - PropertiesSource
6 | - CreateTempFile
7 | - TextFileStream
8 | - ValidateDuration
9 | - HandleGetRequest
10 | - FibonacciSequence
11 |
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/Check Flux/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor:reactor-core'
3 | implementation 'io.projectreactor:reactor-test'
4 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/Check Flux/src/CheckFluxTask.java:
--------------------------------------------------------------------------------
1 | import java.time.Duration;
2 |
3 | import reactor.core.publisher.Flux;
4 | import reactor.test.StepVerifier;
5 |
6 | public class CheckFluxTask {
7 |
8 | public static void verifyThat10ElementsEmitted(Flux flux) {
9 | throw new ToDoException(); // use StepVerifier to perform testing
10 | }
11 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/Check Flux/task.html:
--------------------------------------------------------------------------------
1 |
2 | Test a Flux that returns 10 random elements
3 |
4 | Use StepVerifier#create
5 |
6 |
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/Check Flux/test/TestingTask1Tests.java:
--------------------------------------------------------------------------------
1 | import java.util.Random;
2 |
3 | import org.junit.jupiter.api.Test;
4 | import reactor.core.publisher.Flux;
5 | import reactor.test.publisher.TestPublisher;
6 |
7 | public class TestingTask1Tests {
8 |
9 | @Test
10 | public void testSolution() {
11 | TestPublisher cold = TestPublisher.createCold();
12 |
13 | Flux.fromStream(new Random().ints()
14 | .boxed())
15 | .take(15)
16 | .skip(5)
17 | .subscribe(cold::next, cold::error, cold::complete);
18 |
19 | CheckFluxTask.verifyThat10ElementsEmitted(cold.flux());
20 |
21 | // cold.assertWasSubscribed();
22 | cold.assertWasRequested();
23 | cold.assertWasNotCancelled();
24 | }
25 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/Test Publisher/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor:reactor-core'
3 | implementation 'io.projectreactor:reactor-test'
4 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/Test Publisher/src/Task.java:
--------------------------------------------------------------------------------
1 | import java.time.Duration;
2 | import java.util.function.Function;
3 |
4 | import reactor.core.publisher.Flux;
5 | import reactor.test.StepVerifier;
6 | import reactor.test.publisher.TestPublisher;
7 |
8 | public class Task {
9 |
10 | public static void unitTestAFunction(Function, Flux> functionToTest) {
11 | testSuccessCase(functionToTest);
12 | testFailureCase(functionToTest);
13 | }
14 |
15 | static void testSuccessCase(Function, Flux> functionToTest) {
16 | // produce "1" "2" "100"
17 | throw new ToDoException(); // TODO Check Success Case;
18 | }
19 |
20 | static void testFailureCase(Function, Flux> functionToTest) {
21 | // produce non number string and check NumberFormatException is produced
22 | throw new ToDoException(); // TODO Check Failure Case;
23 | }
24 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/Test Publisher/task.html:
--------------------------------------------------------------------------------
1 |
2 | Unit-Test the given function which accepts and produce a Flux. Manually
3 | supply required elements
4 |
5 |
6 | Use TestPublisher
7 |
8 |
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/Test Publisher/test/TestingTask3Tests.java:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/OlegDokuka/reactive-programming-course-preview/33c29f7b8fd7812f0ef655df4927c6ab8740f486/Reactive Essentials/Testing/Test Publisher/test/TestingTask3Tests.java
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/Test Timed Flux/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor:reactor-core'
3 | implementation 'io.projectreactor:reactor-test'
4 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/Test Timed Flux/src/TestTimedFluxTask.java:
--------------------------------------------------------------------------------
1 | import java.time.Duration;
2 | import java.util.function.Supplier;
3 |
4 | import reactor.core.publisher.Flux;
5 | import reactor.test.StepVerifier;
6 |
7 | public class TestTimedFluxTask {
8 |
9 | public static void verifyEmissionWithVirtualTimeScheduler() {
10 | Supplier> toVerify = () -> Flux.interval(Duration.ofDays(1))
11 | .take(15)
12 | .skip(5);
13 | throw new ToDoException();
14 | }
15 | }
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/Test Timed Flux/task.html:
--------------------------------------------------------------------------------
1 |
2 | Test the given Flux in such a way so execution takes less than a second
3 |
4 |
5 | Use StepVerifier#withVirtualTime
6 |
7 |
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/Test Timed Flux/test/TestingTask2Tests.java:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/OlegDokuka/reactive-programming-course-preview/33c29f7b8fd7812f0ef655df4927c6ab8740f486/Reactive Essentials/Testing/Test Timed Flux/test/TestingTask2Tests.java
--------------------------------------------------------------------------------
/Reactive Essentials/Testing/lesson-info.yaml:
--------------------------------------------------------------------------------
1 | custom_name: "Part 4: Testing"
2 | content:
3 | - Check Flux
4 | - Test Timed Flux
5 | - Test Publisher
6 |
--------------------------------------------------------------------------------
/Reactive Essentials/section-info.yaml:
--------------------------------------------------------------------------------
1 | custom_name: Reactive Essentials
2 | content:
3 | - Sync Publishers
4 | - Async Publishers
5 | - Common Operators
6 | - Testing
7 | - Streaming App
8 |
--------------------------------------------------------------------------------
/Reactive Expert/Context/lesson-info.yaml:
--------------------------------------------------------------------------------
1 | custom_name: "How To: Manage the Context"
2 | content:
3 | - task1
4 | - task2
5 | - task3
6 |
--------------------------------------------------------------------------------
/Reactive Expert/Context/task1/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor:reactor-core'
3 | }
--------------------------------------------------------------------------------
/Reactive Expert/Context/task1/src/Task.java:
--------------------------------------------------------------------------------
1 | import reactor.core.publisher.Mono;
2 |
3 | public class Task {
4 |
5 | public static Mono grabDataFromTheGivenContext(Object key) {
6 | return Mono.error(new ToDoException());
7 | }
8 | }
--------------------------------------------------------------------------------
/Reactive Expert/Context/task1/task.html:
--------------------------------------------------------------------------------
1 |
2 | Retrieve context from the given CoreSubscriber. Use given key in order to
3 | access value stored in the Context
4 |
5 | Use Mono.deferContextual(lambda) in order to access a ContextView.
6 | Use ContextView#get(key)
7 |
8 |
--------------------------------------------------------------------------------
/Reactive Expert/Context/task1/test/ContextTask1Tests.java:
--------------------------------------------------------------------------------
1 | import org.junit.jupiter.api.Test;
2 | import reactor.test.StepVerifier;
3 | import reactor.util.context.Context;
4 |
5 | public class ContextTask1Tests {
6 |
7 | @Test
8 | public void testSolution() {
9 | StepVerifier.create(Task.grabDataFromTheGivenContext("Test")
10 | .contextWrite(Context.of("Test", "Test")))
11 | .expectSubscription()
12 | .expectNext("Test")
13 | .verifyComplete();
14 | }
15 | }
--------------------------------------------------------------------------------
/Reactive Expert/Context/task2/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor:reactor-core'
3 | }
--------------------------------------------------------------------------------
/Reactive Expert/Context/task2/src/Task.java:
--------------------------------------------------------------------------------
1 | import reactor.core.publisher.Mono;
2 | import reactor.util.context.Context;
3 |
4 | public class Task {
5 |
6 | public static Mono provideCorrectContext(Mono source,
7 | Object key,
8 | Object value) {
9 | return Mono.error(new ToDoException());
10 | }
11 | }
--------------------------------------------------------------------------------
/Reactive Expert/Context/task2/task.html:
--------------------------------------------------------------------------------
1 |
2 | Add Context to the Flux
3 |
4 |
5 | Use #contextWrite(Context)
6 |
7 |
--------------------------------------------------------------------------------
/Reactive Expert/Context/task2/test/ContextTask2Tests.java:
--------------------------------------------------------------------------------
1 | import org.junit.jupiter.api.Test;
2 | import reactor.core.publisher.Mono;
3 | import reactor.test.StepVerifier;
4 |
5 | public class ContextTask2Tests {
6 |
7 | @Test
8 | public void testSolution() {
9 | StepVerifier.create(Task.provideCorrectContext(Mono.just("Test"), "Key", "Value"))
10 | .expectSubscription()
11 | .expectAccessibleContext()
12 | .contains("Key", "Value")
13 | .then()
14 | .expectNext("Test")
15 | .verifyComplete();
16 | }
17 | }
--------------------------------------------------------------------------------
/Reactive Expert/Context/task3/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor:reactor-core'
3 | }
--------------------------------------------------------------------------------
/Reactive Expert/Context/task3/src/Task.java:
--------------------------------------------------------------------------------
1 | import org.reactivestreams.Publisher;
2 | import reactor.core.publisher.Flux;
3 | import reactor.util.context.Context;
4 |
5 | public class Task {
6 |
7 | public static Flux provideCorrectContext(Publisher sourceA,
8 | Context contextA,
9 | Publisher sourceB,
10 | Context contextB) {
11 | return Flux.from(sourceA).mergeWith(sourceB);
12 | }
13 | }
--------------------------------------------------------------------------------
/Reactive Expert/Context/task3/task.html:
--------------------------------------------------------------------------------
1 |
2 | Rewrite code in such a way so contextA is available only for
3 | sourceA and contextB only for
4 | sourceB
5 |
6 |
7 | Note, flux1.mergeWith(flux2) under the hood is
8 | Flux.merge(flux1, flux2)
9 |
10 |
--------------------------------------------------------------------------------
/Reactive Expert/Debugging/lesson-info.yaml:
--------------------------------------------------------------------------------
1 | custom_name: "How To: Debug | Log | Meter"
2 | content:
3 | - task1
4 | - task2
5 | - task3
6 |
--------------------------------------------------------------------------------
/Reactive Expert/Debugging/task1/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor.tools:blockhound'
3 | implementation 'io.projectreactor:reactor-tools'
4 | implementation 'io.projectreactor:reactor-core'
5 | implementation 'io.projectreactor:reactor-test'
6 | }
--------------------------------------------------------------------------------
/Reactive Expert/Debugging/task1/task.html:
--------------------------------------------------------------------------------
1 |
2 | Find a source of failure and fix it.
3 | MyCallable is an allowed source of blocking calls. Makes sure a proper
4 | exclusion for BlockHound is written
5 |
6 | Use BlockHoundIntegration
7 | Use Hooks.onOperatorDebug
8 | Use ReactorDebugAgent
9 |
10 |
--------------------------------------------------------------------------------
/Reactive Expert/Debugging/task1/test/DLMTask1Tests.java:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/OlegDokuka/reactive-programming-course-preview/33c29f7b8fd7812f0ef655df4927c6ab8740f486/Reactive Expert/Debugging/task1/test/DLMTask1Tests.java
--------------------------------------------------------------------------------
/Reactive Expert/Debugging/task2/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor.tools:blockhound:1.0.2.RELEASE'
3 | implementation 'io.projectreactor:reactor-tools'
4 | implementation 'io.projectreactor:reactor-core'
5 | implementation 'io.projectreactor:reactor-test'
6 | }
--------------------------------------------------------------------------------
/Reactive Expert/Debugging/task2/src/Task.java:
--------------------------------------------------------------------------------
1 | import java.util.logging.Level;
2 |
3 | import reactor.core.publisher.Flux;
4 | import reactor.core.publisher.SignalType;
5 | import reactor.core.scheduler.Schedulers;
6 |
7 | public class Task {
8 |
9 | public static Flux loggerTask(Flux flux) {
10 | return flux
11 | // TODO add log here. Log only requests
12 | .subscribeOn(Schedulers.parallel())
13 | .publishOn(Schedulers.single());
14 | // TODO add log here.
15 | }
16 | }
--------------------------------------------------------------------------------
/Reactive Expert/Debugging/task2/task.html:
--------------------------------------------------------------------------------
1 |
2 | Properly log your stream before and after Threading operators
3 |
4 | Use Flux#log
5 |
6 |
--------------------------------------------------------------------------------
/Reactive Expert/Debugging/task2/test/DLMTask2Tests.java:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/OlegDokuka/reactive-programming-course-preview/33c29f7b8fd7812f0ef655df4927c6ab8740f486/Reactive Expert/Debugging/task2/test/DLMTask2Tests.java
--------------------------------------------------------------------------------
/Reactive Expert/Debugging/task3/build.gradle:
--------------------------------------------------------------------------------
1 | dependencies {
2 | implementation 'io.projectreactor.tools:blockhound'
3 | implementation 'io.projectreactor:reactor-tools'
4 | implementation 'io.projectreactor:reactor-core'
5 | implementation 'io.projectreactor:reactor-test'
6 | implementation 'io.micrometer:micrometer-core'
7 | }
--------------------------------------------------------------------------------
/Reactive Expert/Debugging/task3/src/Task.java:
--------------------------------------------------------------------------------
1 | import reactor.core.publisher.Flux;
2 | import reactor.core.scheduler.Schedulers;
3 |
4 | public class Task {
5 |
6 | public static Flux metricsTask(Flux flux) {
7 | // TODO scheduler metrics
8 | return flux
9 | // TODO add metrics for flux and name your flux as "MyFlux"
10 | .subscribeOn(Schedulers.parallel())
11 | .publishOn(Schedulers.single())
12 | .log("After PublisherOn");
13 | }
14 | }
--------------------------------------------------------------------------------
/Reactive Expert/Debugging/task3/task.html:
--------------------------------------------------------------------------------
1 |
2 | Enable metrics for your flux. Name your flux as "MyFlux"
3 |
4 | Use Flux#metrics
5 |
6 |
--------------------------------------------------------------------------------
/Reactive Expert/Debugging/task3/test/DLMTask3Tests.java:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/OlegDokuka/reactive-programming-course-preview/33c29f7b8fd7812f0ef655df4927c6ab8740f486/Reactive Expert/Debugging/task3/test/DLMTask3Tests.java
--------------------------------------------------------------------------------
/Reactive Expert/section-info.yaml:
--------------------------------------------------------------------------------
1 | custom_name: Reactive Expert
2 | content:
3 | - Context
4 | - Debugging
5 |
--------------------------------------------------------------------------------
/course-info.yaml:
--------------------------------------------------------------------------------
1 | type: marketplace
2 | title: Reactive Programming Course
3 | language: English
4 | summary: Reactive Programming With Spring And Project Reactor Course
5 | programming_language: Java
6 | content:
7 | - Reactive Essentials
8 | - Reactive Advanced
9 | - Reactive Expert
10 | mode: Study
11 | vendor:
12 | name: Oleh Dokuka
13 |
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.jar:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/OlegDokuka/reactive-programming-course-preview/33c29f7b8fd7812f0ef655df4927c6ab8740f486/gradle/wrapper/gradle-wrapper.jar
--------------------------------------------------------------------------------
/gradle/wrapper/gradle-wrapper.properties:
--------------------------------------------------------------------------------
1 | distributionBase=GRADLE_USER_HOME
2 | distributionPath=wrapper/dists
3 | distributionUrl=https\://services.gradle.org/distributions/gradle-8.3-bin.zip
4 | networkTimeout=10000
5 | zipStoreBase=GRADLE_USER_HOME
6 | zipStorePath=wrapper/dists
7 |
--------------------------------------------------------------------------------
/settings.gradle:
--------------------------------------------------------------------------------
1 | // Should be the same as `com.jetbrains.edu.learning.courseGeneration.GeneratorUtils.sanitizeName`
2 | static String sanitizeName(String name) {
3 | return name.replaceAll("[ /\\\\:<>\"?*|()]", "_")
4 | }
5 |
6 | rootProject.name = 'ReactiveProgrammingCourse'
7 |
8 | rootProject.projectDir.eachDirRecurse {
9 | if (!isTaskDir(it) || it.path.contains(".idea")) {
10 | return
11 | }
12 | def taskRelativePath = rootDir.toPath().relativize(it.toPath())
13 | def parts = []
14 | for (name in taskRelativePath) {
15 | parts.add(sanitizeName(name.toString()))
16 | }
17 | def moduleName = parts.join("-")
18 | include "$moduleName"
19 | project(":$moduleName").projectDir = it
20 | }
21 |
22 | def isTaskDir(File dir) {
23 | return new File(dir, "src").exists()
24 | }
25 |
26 | include 'util'
--------------------------------------------------------------------------------
/util/src/main/java/ToDoException.java:
--------------------------------------------------------------------------------
1 | public class ToDoException extends RuntimeException {
2 |
3 | public ToDoException() {
4 | super();
5 | }
6 |
7 | public ToDoException(String message) {
8 | super(message);
9 | }
10 | }
11 |
--------------------------------------------------------------------------------