Merge branch 'master' into upgrade-dependencies

Author: kbahr

.travis.yml

@@ -34,4 +34,7 @@ cache:
 env:
   global:
   - secure: "ErthuwJHqk8MPlGQcwaSV1mk6DI1z6YHg+XnNUE9yx/EXUqVMyazu5u9VqlZhMMQQm6II8Y8oBF1uK4JdNVKa44xCt8OM3d/HbG5WhYyigNuKaOgK19FGfA7hciY4gzcMsix/lOryqu8JlYqABAIJFwZIJFtnEdylxUO46/PLP01TOHVOrnaUXpTNm6esaXfmgv1ToQCtwALSgo/xy2KYFA6vpzcTYnMii9eMaOZdy3162t8M6equ2WHhqiKvxCX1+M8D76/WoRF1v45dekAV3UKSBf5b3UcK1W1V/NxtwMufD7tXLGxDsBo2JWQOLjx+AyiKGwhVkZBbvfECDKKjq3x5NMjvjqleprYNEKQYibCNvhXVpZPZgKt899RHOXMjt+fr+iq1aHpHU98iFWXyp+MgYbe9Fez/xcWDH9rri+LKsCgZd1PtpDjTjUsZWesAsXYQatTGOZ0w0cOkURbVhUKltnf/AzuhOlj3XqJmO30vKiBhtwzyfvrURc+0GqWlRoU0C1qskmtmI10PJRR1Qv3eMKvvi6XIQfit9J01V/0sJ+WoG6980hJy0N421qr1+LNg3WmDGtMp6UyoAvjUbDFaW3xzGdbsNmLzWqfaFY1kM7ry6WaVVbGEYz0uHKEvMnqLrM3t18qO4wQsaskGCYEaYSmFp4oMT4pDRgCzvU="
-  - secure: "G+FkJfEGeUdBFtMtZSZJxyTvdlD8IJnAuznEXuxsApL2khEsOtojTDEHJuE0nyVLFrxe5eFfbF/X2AHIQ7bgH0CPQKoT9GtVZJQDrLbDONzGQNbIUtmo+xIfpPmfmGxWiRTaovyU3K3KWJdU5s6sokMpCqNeTNgugzDstC2QFawmSL4BtVqMP5t9LrTbRw+FR7NkSZ2HCuad80RrYAOir1jqi7852AKzUACvvOwgZRbaaWGSTxdow3V3pJGGw2k8fx7C1vYaucKGhgkV9dT1GgHAV4TyXzEWfBhIofG3aqAT4d/sVLFKcsh6ixBLDe29mCchWyhB24eaLlArjerDVFy+bCMWHsLYXHtqSpZAyyi8DEHMpFalfpCif9OhNcCTlBrUkr58i1P6Ru6lVmzsW9FhijtNmX4Hdz+BRCQJB7G1zYwULOYG+mQTDmHBGP8lUswaCwD4kxMjfZBna23gsD4z8r3WWMbaG0zRuUuX7gnApI/LYaSbm9eM+ef5IEYOwvA5uf/ZRsSyoetcmI+hGHiFPZUUgCg2SI/RWyB2XAuHBsD//cHWF9JiFv0av0/19HkryRSjGo029qa456BDI4yTTRfT0L6oUjCtjXGOVmWkkd1TB/G8oidPjB3HCGMttKrSpdB0Y6RrVzjZJueqqaCOZ2X4+ksqc4PB3vZR8vo="
+  - secure: "sQYup+Bn5NeIKRa1EWMcgWyfP4kHmD5WZ0slTIjZjGRBqqAR7SdRv1XklkEoUE2BXKxEmhKn5bPA3itmn0ix3N4y9km0q9DRQ0RJF+MFJcSg0CYpSlfjGUEUGoIdYQjreZ+AETAyniLGDVE28tWBQ+GliwfKViiE0LESDihfcqUe/7lcDuc/UMP9h7ecazLjwCmmVNYM94ZfTVoPrbC3Jdtb1sPd65/yZPj7pgBzk/vh82E5tmo0JYr81Rq8CKiYoQ2W7qiTmKL/X33mVxvC9lRRNoqgfAyofgnv5zMbvj1krCcKrkuOJ+A/wTOnkZ1MEL/YK0ilNw0g9oxY0MRXEq9jvms4M2bvGyj0jdKB+ctsXMf9l7ZvWdj1kTEHguQxpjg6hhxrwjRwKk5y0LPJFi3Nqxet00+aB2Wqg1AJ5KwBZ9s2e6nhfAOMnWFVct8mxnFfb/8cu1XfyET5ABBK7PozpcY8VQUVqpoSheKuGdFYRXXgA4o42t+Uxt8G/XX5TRJpaD2FtPa9YwtsrCx6HtCEVetSFZ6X0JeHPdzLBn3XTqyPBoc4bD28VFnEs1NKj+Sbj09sDKH93HQ+PafcJnFiPC7Pdk7NedHCqmEXtppvA+L4pL0V9zDNn93pKLgXsCovcrX7nCnfWk2IjGnDMgZaxWPnW0r0AWsl0BwbqjM="
+  - secure: "eV4F5Jp3n8Qi79ATwAUvQdhhZzg/jxKVpTe1ovF0paSWtETe5Whuqb+52nLF4um8NrXDLuTM2Ms12o2rUThaqnEgKWR9HSgwXaBNyYs1zWL3J5+nhrX4/jMKtZ+VY3pH+Sk5KiDgf/jModLrXk6k7uN330PKA3hVLlzA0qc+4QXtnwZNZOQ9sjQsScVxAJ6hBJ8TpUZy4ragg07LTa87p679YFXmsClIQcLdY2eTAIXgNuv0HAe1Eyog3Q5m/ObOdQD0fO3M9Qj9QHWWeh6Rc7dcDA8Nvd6peN+dLaG7DK7Gj+lLyx3K6iXrnHzBHHg1sKKcMeejxxD/0d/auzaqP2ORudSYrblo26AU9fHEUKkdcGS0m5NwOYF9slB1U8KXbIFPPNT+W48h8OgTKPErDvnliujirPBpF9pAC8vRhRORMMbKWQIr14HrxhJ9EBhfJ6iDVBM+xEjVzAOxjRuXia8o5Bzo3rmQwDO+Wvb1bJOZ0u7gPwNkMJF7Nj7ScEx1JLaw2RW1/xhQADxoh74NnNr3XJlicoyLZx+mDNOu0wkW0Q/F04FDlCy78VhSMgoiGPNWDtrjCWWFUhSSCbZFL5sjqFXjz24v0raqKqT12oOUwX9ueeIb0gQsMVj8zSnb7F7oZJpbKaPdofS5eEuNMSKzoJ7Imx5mkryMoL0Czic="
+  - secure: "RU3x9rPkGiMVN1YBsNcqzpjLuR7AZMvnVrDzOKH02jDByk9H1tnVmLcodb9d/HcWjiimp+YQ6urCrUbf+kk1kphLZIC1It0vRqYgTFk8KDmP9ilZSkwzHd+uL5eDwupuv5ZkpXJUUNGHVZ0tMcQMKPc1gltuAY5wlH6v4N/irogwF0Lr0ySwzCNP/0286xGo7nAp4QU2iIOHrKDsyMpSq52YWa06/Ypo6OamNyeP+ptm+TsSWzJRmwvgh23uTNEjSVCMCTrf2w3tjSwr0vmxnMAd5vltuoQXNhTpr+P/O/uOW6YXZNzl25G3LAgwImErYrz6CN2H0tfHWbaxOPWrbTgeKUklxHrkGY42vQwNn3zIke/yNSWdUFjtKKv/8pFN+MI+Y2q7ugM4ORqyba5vZdngG0cuaHiwv0ITsvP/guCJKBOCpY0j9RbULctFfhxyVBcjneepaXb+BMPSWeMnhMvt3G3MV0LrrkjpzuBo0HgDmRo1D6dRHArQ0/V2oWV86/ZuS5cpbe0R5hZRNSXTvlJq/BIA6KVO6RFVLAKrnGjT7/cNWH1QFzAS1qTPgxefZxGb8T1vPJ12d+LDhuyqUTnd029PMSkCUzlm5EyeIvYG6auH6T2l9Q7FgIhCT6hBZNxGbavR5XyfnBg9sE+OQJmta9GjyJCdiGBJmIGKW2s="
+

README.md

@@ -4,6 +4,7 @@
 The standard [RSocket](http://rsocket.io) RPC Java implementation.
 
 ## Build from Source
+
 1. Building rsocket-rpc-java requires installation of the [Protobuf](https://github.com/google/protobuf) compiler. RSocket RPC requires Protobuf 3.6.x or higher.
 
     For Mac users you can easily install the Protobuf compiler using Homebrew:
@@ -15,8 +16,18 @@ The standard [RSocket](http://rsocket.io) RPC Java implementation.
 2. Run the following Gradle command to build the project:
 
         $ ./gradlew clean build
+        
+## What Next?
+
+ * [Motivation](./docs/motivation.md)
+ * [Get Started](./docs/get-started.md)  
+
+## Release Notes
+
+Please find release notes at [https://github.com/rsocket/rsocket-rpc-java/releases](https://github.com/rsocket/rsocket-rpc-java/releases).
 
 ## Bugs and Feedback
+
 For bugs, questions, and discussions please use the [Github Issues](https://github.com/netifi/rsocket-rpc-java/issues).
 
 ## License

bintray.gradle

@@ -14,7 +14,8 @@
  * limitations under the License.
  */
 
-if (project.hasProperty('bintrayUser') && project.hasProperty('bintrayKey')) {
+if (project.hasProperty('bintrayUser') && project.hasProperty('bintrayKey') &&
+    project.hasProperty('sonatypeUsername') && project.hasProperty('sonatypePassword')) {
 
     subprojects {
         plugins.withId('com.jfrog.bintray') {
@@ -46,10 +47,10 @@ if (project.hasProperty('bintrayUser') && project.hasProperty('bintrayKey')) {
                             sign = true
                         }
 
-//                        mavenCentralSync {
-//                            user = project.property('sonatypeUsername')
-//                            password = project.property('sonatypePassword')
-//                        }
+                        mavenCentralSync {
+                            user = project.property('sonatypeUsername')
+                            password = project.property('sonatypePassword')
+                        }
                     }
                 }
             }

build.gradle

@@ -38,16 +38,16 @@ subprojects {
     sourceCompatibility = 1.8
     targetCompatibility = 1.8
 
-
     ext['reactor-bom.version'] = 'Californium-SR2'
     ext['rsocket.version'] = '0.11.11'
 
     ext['protobuf.version'] = '3.6.1'
     ext['log4j.version'] = '2.9.0'
+    ext['slf4j.version'] = '1.8.0-beta2'
     ext['junit.version'] = '5.1.0'
     ext['mockito.version'] = '2.23.0'
     ext['hamcrest.version'] = '1.3'
-    ext['jmh.version'] = '1.2.0'
+    ext['jmh.version'] = '1.21'
     ext['micrometer.version'] = '1.0.6'
     ext['assertj.version'] = '3.11.1'
     ext['opentracing.version'] = '0.31.0'
@@ -76,7 +76,11 @@ subprojects {
 
         dependencies {
 
-            dependency "com.google.protobuf:protobuf-java:${ext['protobuf.version']}"
+            dependencySet(group: 'com.google.protobuf', version: ext['protobuf.version']) {
+                entry 'protobuf-java'
+                entry 'protoc'
+            }
+            dependency "com.google.protobuf:protoc:${ext['protobuf.version']}"
 
             dependency "javax.inject:javax.inject:1"
 		  	dependency "javax.annotation:javax.annotation-api:1.2"
@@ -86,6 +90,7 @@ subprojects {
                 entry "log4j-core"
                 entry "log4j-slf4j-impl"
             }
+            dependency "org.slf4j:slf4j-simple:${ext['slf4j.version']}"
 
             dependencySet(group: 'io.rsocket', version: ext['rsocket.version']) {
                 entry 'rsocket-core'

docs/index.md docs/get-started.mddocs/index.md renamed to docs/get-started.md

@@ -1,4 +1,7 @@
-RSocket RPC Java
+# Get Started with RSocket RPC Java
+
+In this section we are going to learn the essential of RSocket-RPC and its implementation in Java
+
 ## Introduction
 RSocket RPC is an easy to use RPC layer that sits on top of [RSocket](http://rsocket.io). RSocket is a binary protocol for use on byte stream transports such as TCP, WebSockets, and [Aeron](https://github.com/real-logic/aeron). RSocket RPC is able to leverage RSockets unique features allowing you develop complex realtime, streaming applications without needing Kafka, Spark, etc. It is completely non-blocking and reactive making it responsive and high performance.
 
@@ -88,7 +91,7 @@ protobuf {
     }
     plugins {
         rsocketRpc {
-            artifact = 'io.rsocket.rpc:rsocket-rpc-protobuf:0.2.5'
+            artifact = 'io.rsocket.rpc:rsocket-rpc-protobuf:0.2.4'
         }
     }
     generateProtoTasks {
@@ -100,12 +103,19 @@ protobuf {
 
 // If you use Intellij add this so it can find the generated classes
 idea {
-    module {
-        sourceDirs += file("${projectDir}/build/generated/source/proto/main/java");
-        sourceDirs += file("${projectDir}/build/generated/source/proto/main/rsocketRpc");
-        sourceDirs += file("${projectDir}/build/generated/source/proto/test/java");
-        sourceDirs += file("${projectDir}/build/generated/source/proto/test/rsocketRpc");
-    }
+  module {
+	sourceDirs += file("src/main/proto")
+	sourceDirs += file("src/generated/main/java")
+	sourceDirs += file("src/generated/main/rsocketRpc")
+
+	generatedSourceDirs += file('src/generated/main/java')
+	generatedSourceDirs += file('src/generated/main/rsocketRpc')
+  }
+}
+
+// clean generated code
+clean {
+  delete 'src/generated/main'
 }
 ```
 
@@ -168,13 +178,13 @@ Here is what the simple `SimpleService` is actually and interface, and represent
 ```
 class DefaultSimpleService implements SimpleService {
     @Override
-    public Mono<Void> fireAndForget(SimpleRequest message) {
-      System.out.println("got message -> " + message.getRequestMessage());
-      return Mono.empty();
-    }
+	public Mono<Empty> fireAndForget(SimpleRequest message, ByteBuf metadata) {
+	  System.out.println("got message -> " + message.getRequestMessage());
+	  return Mono.just(Empty.getDefaultInstance());
+	}
     
     @Override
-    public Mono<SimpleResponse> requestReply(SimpleRequest message) {
+    public Mono<SimpleResponse> requestReply(SimpleRequest message, ByteBuf metadata) {
       return Mono.fromCallable(
           () ->
               SimpleResponse.newBuilder()
@@ -183,7 +193,7 @@ class DefaultSimpleService implements SimpleService {
     }
     
     @Override
-    public Mono<SimpleResponse> streamingRequestSingleResponse(Publisher<SimpleRequest> messages) {
+    public Mono<SimpleResponse> streamingRequestSingleResponse(Publisher<SimpleRequest> messages, ByteBuf metadata) {
       return Flux.from(messages)
           .windowTimeout(10, Duration.ofSeconds(500))
           .take(1)
@@ -219,7 +229,7 @@ class DefaultSimpleService implements SimpleService {
     }
     
     @Override
-    public Flux<SimpleResponse> requestStream(SimpleRequest message) {
+    public Flux<SimpleResponse> requestStream(SimpleRequest message, ByteBuf metadata) {
       String requestMessage = message.getRequestMessage();
       return Flux.interval(Duration.ofMillis(200))
           .onBackpressureDrop()
@@ -228,51 +238,45 @@ class DefaultSimpleService implements SimpleService {
     }
     
     @Override
-    public Flux<SimpleResponse> streamingRequestAndResponse(Publisher<SimpleRequest> messages) {
-      return Flux.from(messages).flatMap(this::requestReply);
+    public Flux<SimpleResponse> streamingRequestAndResponse(Publisher<SimpleRequest> messages, ByteBuf metadata) {
+      return Flux.from(messages).flatMap(e -> requestReply(e, metadata));
     }
 }
 ```
 
 ### RSocket RPC Server Configuration
 Each generated service has a client and server implementation generated for you. After you have implemented the generated interface you need to hand the implementation to the  server. See the below example:
 ```
-SimpleServiceServer serviceServer = new SimpleServiceServer(new DefaultSimpleService());
+SimpleServiceServer serviceServer = new SimpleServiceServer(new DefaultSimpleService(), Optional.empty(), Optional.empty());
 ```
 
-Once you have created an instance of the the server you need to configure RSocket. The server can either be configured the RSocket that receives the connection or the RSocket that makes the connection. The following examples uses TCP, but can use other transports as well. The example also uses the optional `RequestHandlingRSocket`. The `RequestHandlingRSocket` is a special RSocket that will allow you to support more than one RSocket RPC Server implementation on the same RSocket connection. If you don't need to support more than one socket you don't need to use it. Just return the generated server directly.
+Once you have created an instance of the the server you need to configure RSocket. The 
+following is a RSocket server configuration
 
-#### RSocket Server Configuration
-This configures the receiver of a connection, typically a server, to handle requests to the `SimeplService` implementation.
-```
-SimpleServiceServer serviceServer = new SimpleServiceServer(new DefaultSimpleService());
-  
-    RSocketFactory.receive()
-        .acceptor(
-            (setup, sendingSocket) ->
-                Mono.just(new RequestHandlingRSocket(serviceServer)))
-        .transport(TcpServerTransport.create(8801))
+```java
+CloseableChannel closeableChannel = RSocketFactory
+        .receive()
+        .acceptor((setup, sendingSocket) -> Mono.just(
+            new RequestHandlingRSocket(serviceServer)
+        ))
+        .transport(TcpServerTransport.create(8081))
         .start()
         .block();
 ```
 
-#### RSocket Client Configuration
-This configures a initiator of a connection, typically a client, to handle requests to the `SimpleService` implementation.
-```
-SimpleServiceServer serviceServer = new SimpleServiceServer(new DefaultSimpleService());
+#### RSocket RPC Client common Configuration
+The RSocket RPC compiler generates a client as well as a server. The client implements the generated interface. You can configure the client either from an RSocket client connection, or server connection. The following shows how to  configure a initiator of a connection, typically a client, to send requests to the `SimpleService` implementation.
 
-RSocketFactory
-        .connect()
-        .acceptor(rSocket -> new RequestHandlingRSocket(serviceServer))
-        .transport(TcpClientTransport.create(8801))
-        .start()
-        .block();
+```java
+RSocket rSocket = RSocketFactory
+	.connect()
+	.transport(TcpClientTransport.create(8801))
+	.start()
+	.block();
+SimpleServiceClient serviceClient = new SimpleServiceClient(rSocket);
 ```
 
-### RSocket RPC Client Configuration
-The RSocket RPC compiler generates a client as well as a server. The client implements the generated interface. You can configure the client either from an RSocket client connection, or server connection.
-
-#### RSocket Server Configuration
+#### RSocket RPC client over Server Configuration
 This configures the receiver of a connection, typically a server, to call the remote  `SimpleService`. Notice that the client is created inside the closure in the acceptor method. The method passes in a variable called `sendingSocket`. This is the RSocket that is the connection to the client. You  can make calls to the client *without* receiving requests first, or ever.
 ```
 RSocketFactory.receive()
@@ -297,17 +301,8 @@ RSocketFactory.receive()
         .block();
 ```
 
-#### RSocket Client Configuration
-This configures an initiator of a connection, typically a client, to call the remote  `SimpleService`.
-```
-RSocket rSocket = RSocketFactory.connect().transport(TcpClientTransport.create(8801)).start().block();
-
-SimpleServiceClient client = new SimpleServiceClient(rSocket);
-
-```
-
 ### Calling the client
-One the client is created, it can be called like any other method. Here is an example call the `streamingRequestSingleResponse` method.
+Once the client is created, it can be called like any other method. Here is an example call the `streamingRequestSingleResponse` method.
 ```
 SimpleServiceClient client = new SimpleServiceClient(rSocket);
 
@@ -321,21 +316,8 @@ SimpleResponse response = client.streamingRequestSingleResponse(requests).block(
 System.out.println(response.getResponseMessage());
 ```
 
-The above example streams in 11 items to a server. The server receives the stream, counts the most common words, and then returns a message detailing the data received. 
-
-## Release Notes
-
-Please find release notes at [https://github.com/netifi/rsocket-rpc-java/releases](https://github.com/netifi/rsocket-rpc-java/releases).
-
-## Bugs and Feedback
-
-For bugs, questions, and discussions please use the [Github Issues](https://github.com/netifi/rsocket-rpc-java/issues).
-
-## License
-Copyright 2017 Netifi Inc.
-
-Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at
+The above example streams in 11 items to a server. The server receives the stream, counts the most common words, and then returns a message detailing the data received.
 
-http://www.apache.org/licenses/LICENSE-2.0
+## Next Steps
 
-Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+See `rsocket-rpc-examples` for more examples and use-cases.

docs/motivation.md

@@ -0,0 +1,7 @@
+# Motivation for RSocket-RPC
+
+As many of us might know, there is an RPC project called gRPC. The gRPC project allows us easily setup RPC communication between several services. Even though the communication is reactive, asynchronous and non-blocking, the current implementation of gRPC does not allow to achieve one of the central goals for Reactive Streams - Backpressure control. At that moment, gRPC uses HTTP/2 as a transport and employee its flow control in order to achieve backpressure. HTTP/2 flow allows only byte-acknowledgment-based flow control, which means there is no specific part of the protocol that can say how many logical-elements a consumer ready to accept. That limitation may impact system stability under high-load which may be either performance degradation or resilience degradation.
+
+Therefore, RSocket-RPC comes for rescue. The central idea of RSocket-RPC is to provide identical communication features as there are in gRPC. As we might remember, gRPC offers Protocol Buffer integration, which along with common data structures generation, allows generating stubs for services. The RSocket-RPC library employees the same techniques and provides the same plugin for stub generation. In turn, RSocket-RPC uses RSocket protocol as an application level transport for message exchange which includes out-of-the-box logical-elements-based backpressure control, therefore offers better resilience without impact on system's performance.
+
+Also, RSocket-RPC is language agnostic and at the current moment provides integration with [JavaScript](https://github.com/rsocket/rsocket-rpc-js) as well as with [Java](https://github.com/rsocket/rsocket-rpc-java).

gradle.properties

@@ -1,2 +1,2 @@
 group=io.rsocket.rpc
-version=0.2.6.BUILD-SNAPSHOT
+version=0.2.5.BUILD-SNAPSHOT

rsocket-rpc-core/build.gradle

@@ -4,13 +4,13 @@ description = 'RSocket RPC Library'
 
 dependencies {
     implementation project (':rsocket-rpc-protobuf')
-    implementation 'io.opentracing:opentracing-api'
-    implementation 'javax.inject:javax.inject'
-    implementation 'javax.annotation:javax.annotation-api'
     implementation 'com.google.protobuf:protobuf-java'
-    implementation 'io.rsocket:rsocket-core'
-    implementation 'io.rsocket:rsocket-transport-netty'
-    implementation 'io.micrometer:micrometer-core'
+
+    api 'io.opentracing:opentracing-api'
+    api 'javax.inject:javax.inject'
+    api 'javax.annotation:javax.annotation-api'
+    api 'io.rsocket:rsocket-core'
+    api 'io.micrometer:micrometer-core'
 
     protobuf project(':rsocket-rpc-metrics-idl')
 
@@ -42,7 +42,7 @@ protobuf {
     generatedFilesBaseDir = "${projectDir}/src/generated"
 
     protoc {
-        artifact = "com.google.protobuf:protoc:${ext['protobuf.version']}"
+        artifact = "com.google.protobuf:protoc"
     }
     plugins {
         rsocketRpc {