jasync-sql · oshai · May 15, 2019 · Apr 14, 2019 · Apr 16, 2019 · Apr 16, 2019
diff --git a/build.gradle b/build.gradle
@@ -21,7 +21,7 @@ allprojects {
         mavenCentral()
         jcenter()
         maven {
-            url "https://repo.spring.io/libs-snapshot/"
+            url "https://repo.spring.io/milestone"
         }
     }
     apply plugin: 'kotlin'

diff --git a/db-async-common/src/main/java/com/github/jasync/sql/db/util/ChannelFutureTransformer.kt b/db-async-common/src/main/java/com/github/jasync/sql/db/util/ChannelFutureTransformer.kt
@@ -1,6 +1,7 @@
 package com.github.jasync.sql.db.util
 
 import com.github.jasync.sql.db.exceptions.CanceledChannelFutureException
+import io.netty.channel.Channel
 import io.netty.channel.ChannelFuture
 import io.netty.channel.ChannelFutureListener
 import java.util.concurrent.CompletableFuture
@@ -9,12 +10,12 @@ import java.util.concurrent.Executor
 fun ChannelFuture.toCompletableFuture(): CompletableFuture<ChannelFuture> {
     val promise = CompletableFuture<ChannelFuture>()
 
-    installOnFuture(promise)
+    installOnChannelFuture(promise)
 
     return promise
 }
 
-fun ChannelFuture.installOnFuture(promise: CompletableFuture<ChannelFuture>) {
+fun ChannelFuture.installOnChannelFuture(promise: CompletableFuture<ChannelFuture>) {
     val listener = ChannelFutureListener { future ->
         if (future.isSuccess) {
             promise.complete(future)
@@ -29,6 +30,21 @@ fun ChannelFuture.installOnFuture(promise: CompletableFuture<ChannelFuture>) {
     }
     this.addListener(listener)
 }
+fun ChannelFuture.installOnFuture(promise: CompletableFuture<Channel>) {
+    val listener = ChannelFutureListener { future ->
+        if (future.isSuccess) {
+            promise.complete(future.channel())
+        } else {
+            val exception = if (future.cause() == null) {
+                CanceledChannelFutureException(future)
+            } else {
+                future.cause()
+            }
+            promise.completeExceptionally(exception)
+        }
+    }
+    this.addListener(listener)
+}
 
 
 fun ChannelFuture.onFailure(executor: Executor, handler: (Throwable) -> Unit) {

diff --git a/mysql-async/src/main/java/com/github/jasync/sql/db/mysql/codec/MySQLConnectionHandler.kt b/mysql-async/src/main/java/com/github/jasync/sql/db/mysql/codec/MySQLConnectionHandler.kt
@@ -39,6 +39,7 @@ import io.netty.bootstrap.Bootstrap
 import io.netty.buffer.ByteBuf
 import io.netty.buffer.ByteBufAllocator
 import io.netty.buffer.Unpooled
+import io.netty.channel.Channel
 import io.netty.channel.ChannelFuture
 import io.netty.channel.ChannelHandlerContext
 import io.netty.channel.ChannelInitializer
@@ -81,9 +82,9 @@ class MySQLConnectionHandler(
 
     fun connect(): CompletableFuture<MySQLConnectionHandler> {
         this.bootstrap.channel(NettyUtils.getSocketChannelClass(this.group))
-        this.bootstrap.handler(object : ChannelInitializer<io.netty.channel.Channel>() {
+        this.bootstrap.handler(object : ChannelInitializer<Channel>() {
 
-            override fun initChannel(channel: io.netty.channel.Channel) {
+            override fun initChannel(channel: Channel) {
                 channel.pipeline().addLast(
                     decoder,
                     encoder,
@@ -283,11 +284,16 @@ class MySQLConnectionHandler(
 
     fun write(message: AuthenticationSwitchResponse): ChannelFuture = writeAndHandleError(message)
 
-    fun sendQuitMessage(): CompletableFuture<ChannelFuture> {
-        val future = CompletableFuture<ChannelFuture>()
-        this.currentContext!!.channel().eventLoop().execute {
+    fun sendQuitMessage(): CompletableFuture<Channel> {
+        val future = CompletableFuture<Channel>()
+        val channel = this.currentContext!!.channel()
+        channel.eventLoop().execute {
             this.clearQueryState()
-            writeAndHandleError(QuitMessage.Instance).installOnFuture(future)
+            if (channel.isActive) {
+                writeAndHandleError(QuitMessage.Instance).installOnFuture(future)
+            } else {
+                future.complete(channel)
+            }
         }
         return future
     }

diff --git a/mysql-async/src/test/java/com/github/jasync/sql/db/mysql/QuerySpec.kt b/mysql-async/src/test/java/com/github/jasync/sql/db/mysql/QuerySpec.kt
@@ -37,9 +37,21 @@ class QuerySpec : ConnectionHelper() {
                 executeQuery(connection, "this is not SQL")
             }
             assertThat((e as MySQLException).errorMessage.sqlState).isEqualTo("#42000")
+            assertThat(e.errorMessage.errorCode).isEqualTo(1064)
         }
     }
 
+    @Test
+    fun `"connection" should   "raise an exception upon incorrect user" `() {
+        val e = verifyException(ExecutionException::class.java, MySQLException::class.java) {
+            withConfigurableConnection(ContainerHelper.defaultConfiguration.copy(username = "not exists")) { connection ->
+                executeQuery(connection, "select 1")
+            }
+        }
+        assertThat((e as MySQLException).errorMessage.sqlState).isEqualTo("#28000")
+        assertThat(e.errorMessage.errorCode).isEqualTo(1045)
+    }
+
 
     @Test
     fun `"connection" should   "be able to select from a table" `() {
@@ -322,7 +334,14 @@ class QuerySpec : ConnectionHelper() {
         val interceptor = ForTestingQueryInterceptor()
         MDC.put("a", "b")
         val mdcInterceptor = MdcQueryInterceptorSupplier()
-        withConfigurablePool(ContainerHelper.defaultConfiguration.copy(interceptors = listOf(Supplier<QueryInterceptor> { interceptor }, mdcInterceptor)))
+        withConfigurablePool(
+            ContainerHelper.defaultConfiguration.copy(
+                interceptors = listOf(
+                    Supplier<QueryInterceptor> { interceptor },
+                    mdcInterceptor
+                )
+            )
+        )
         { connection ->
             assertThat(executeQuery(connection, this.createTable).rowsAffected).isEqualTo(0)
             assertThat(executeQuery(connection, this.insert).rowsAffected).isEqualTo(1)

diff --git a/r2dbc-mysql/build.gradle b/r2dbc-mysql/build.gradle
@@ -2,7 +2,7 @@
 dependencies {
     compile project(':mysql-async')
     compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8:$kotlin_version"
-    compile "io.r2dbc:r2dbc-spi:1.0.0.M7"
+    compile "io.r2dbc:r2dbc-spi:0.8.0.M8"
     implementation "io.projectreactor:reactor-core:3.2.6.RELEASE"
     compile "org.slf4j:slf4j-api:$sl4j_version"
     compile "joda-time:joda-time:$joda_version"

diff --git a/r2dbc-mysql/src/main/java/JasyncDatabaseException.kt b/r2dbc-mysql/src/main/java/JasyncDatabaseException.kt
@@ -0,0 +1,8 @@
+package com.github.jasync.r2dbc.mysql
+
+import io.r2dbc.spi.R2dbcException
+
+class JasyncDatabaseException(reason: String,
+                              sqlState: String,
+                              errorCode: Int,
+                              cause: Throwable): R2dbcException(reason, sqlState, errorCode, cause)
diff --git a/r2dbc-mysql/src/main/java/JasyncMetadata.kt b/r2dbc-mysql/src/main/java/JasyncMetadata.kt
@@ -62,4 +62,6 @@ class JasyncMetadata(rows: ResultSet) : RowMetadata {
             return name
         }
     }
-}
+
+    override fun getColumnNames(): Collection<String> = columnNames
+}
diff --git a/r2dbc-mysql/src/main/java/JasyncStatement.kt b/r2dbc-mysql/src/main/java/JasyncStatement.kt
@@ -1,12 +1,21 @@
 package com.github.jasync.r2dbc.mysql
 
 import com.github.jasync.sql.db.QueryResult
+import com.github.jasync.sql.db.exceptions.ConnectionTimeoutedException
+import com.github.jasync.sql.db.exceptions.InsufficientParametersException
+import com.github.jasync.sql.db.mysql.exceptions.MySQLException
+import io.r2dbc.spi.R2dbcBadGrammarException
+import io.r2dbc.spi.R2dbcDataIntegrityViolationException
+import io.r2dbc.spi.R2dbcPermissionDeniedException
+import io.r2dbc.spi.R2dbcTimeoutException
 import io.r2dbc.spi.Result
 import io.r2dbc.spi.Statement
 import org.reactivestreams.Publisher
 import reactor.core.publisher.Mono
+import reactor.core.publisher.onErrorMap
 import reactor.core.publisher.toFlux
 import reactor.core.publisher.toMono
+import java.io.IOException
 import java.util.function.Supplier
 import com.github.jasync.sql.db.Connection as JasyncConnection
 
@@ -89,7 +98,49 @@ internal class JasyncStatement(private val clientSupplier: Supplier<JasyncConnec
             } else {
                 extraGeneratedQuery(connection, connection.sendQuery(sql).toMono())
             }
-        }.map { JasyncResult(it.rows, it.rowsAffected) }
+        }
+            .map { JasyncResult(it.rows, it.rowsAffected) }
+            .onErrorMap(Throwable::class) { throwable ->
+                when (throwable) {
+                    is ConnectionTimeoutedException -> R2dbcTimeoutException(throwable)
+                    is IllegalArgumentException -> throwable
+                    is IllegalStateException -> throwable
+                    is UnsupportedOperationException -> throwable
+                    is IOException -> throwable
+                    is MySQLException -> {
+                        val errorMessage = throwable.errorMessage
+                        when {
+                            errorMessage.errorCode == 1044 -> R2dbcPermissionDeniedException(
+                                errorMessage.errorMessage,
+                                errorMessage.sqlState,
+                                errorMessage.errorCode,
+                                throwable
+                            )
+                            errorMessage.errorCode == 1045 -> R2dbcPermissionDeniedException(
+                                errorMessage.errorMessage,
+                                errorMessage.sqlState,
+                                errorMessage.errorCode,
+                                throwable
+                            )
+                            errorMessage.errorCode == 1064 -> R2dbcBadGrammarException(
+                                errorMessage.errorMessage,
+                                errorMessage.sqlState,
+                                errorMessage.errorCode,
+                                sql,
+                                throwable
+                            )
+                            else -> JasyncDatabaseException(
+                                errorMessage.errorMessage,
+                                errorMessage.sqlState,
+                                errorMessage.errorCode,
+                                throwable
+                            )
+                        }
+                    }
+                    is InsufficientParametersException -> R2dbcDataIntegrityViolationException(throwable.message, throwable)
+                    else -> R2dbcTimeoutException(throwable)
+                }
+            }
     }
 
     private fun extraGeneratedQuery(connection: JasyncConnection, result: Mono<QueryResult>): Mono<QueryResult> {

diff --git a/r2dbc-mysql/src/main/java/MysqlConnectionFactoryProvider.kt b/r2dbc-mysql/src/main/java/MysqlConnectionFactoryProvider.kt
@@ -53,4 +53,6 @@ class MysqlConnectionFactoryProvider : ConnectionFactoryProvider {
             else -> true
         }
     }
+
+    override fun getDriver(): String = MYSQL_DRIVER
 }
-Original file line number
+Diff line change
@@ Expand Up / @@ -62,4 +62,6 @@ class JasyncMetadata(rows: ResultSet) : RowMetadata { @@
                 return name
             }
         }
-    }
+        override fun getColumnNames(): Collection<String> = columnNames
+    }