Thinking out loud, can we somehow associate config with a dependency and automatically download and attach them?

@sdeleuze you might be interested in IJ async stacks as well

Hi guys, did anybody manage to solve the issue of generating Service Proxies for Vert.x with Gradle, using Kotlin only (i.e. no Java interfaces)?

I think you can run GSK scripts as far as I remember

To think the Kotlin example is bad. Just wait until you look at this Kotlin example with callback hell amplified, aaaah! https://github.com/vert-x3/vertx-examples/blob/master/jdbc-examples/src/main/kotlin/io/vertx/example/jdbc/streaming/JDBCExample.kt 😱

@napperley any feedback to provide ? I’m aiming to merge this into master this week

For Gradle users, here is a Vert.x plugin: https://github.com/jponge/vertx-gradle-plugin

Arent coroutines experimental? Does anyone use them in production without problems, im also making an api in vertx, but im currently using rxjava...

Julien - Yes for development. Already using hot reload. Copying over the JS file(s) (transpiled via the kotlinjs transpiler) to the server does trigger a hot reload. Thought that hot reload would reset the cache, which doesn't appear to be the case. Tried disabling the server cache:

val publicHandler = StaticHandler.create("public").apply {
            setCachingEnabled(false)
        }

        router.route("/public/*").handler(publicHandler)

, unfortunately that doesn't make a difference 😦 so the Vert.x Google group is the best hope for a resolution 🐰.

can you provide a reproducer with web client ?

Vert.x is great, but one thing that os missing is cache that expires older entries and can be reset... Or maybe I missed something?

@julienviet Is there any easier way to work with Buffer and strings than encoding turning into bytes sending size int then sending string? I'm sure that such a common use case can be automated...?

Should I to keep a global reference to vertx object or use Vertx.vertx() every where?

becuase the doc in the current vertx-lang-kotlin repo is hard to get on the web-site after release

@dave08 this is what I’m doing :

object JsonObjectUtils{
     inline operator fun JsonObject.set(key: String, value: Any): Unit {
        this.put(key,value)
    }
    inline operator fun <T> JsonObject.get(key: String): T {
        return this.getValue(key) as T
    }
    fun  JsonObject.getFlow(): JsonObject {
        return this.getJsonObject("flow")
    }
    fun  JsonObject.getFlowNodeId(): String {
        return this.getFlow().get("nodeId")
    }
    fun  JsonObject.setFlowNodeId(nodeId:String) {
        this.getFlow().put("nodeId",nodeId)
    }
    fun  JsonObject.getFlowName(): String {
        return this.getFlow().get("name")
    }
    fun  JsonObject.setFlowName(nodeId:String) {
        this.getFlow().put("name",nodeId)
    }
}

the current kotlin as far as I remember is 1.1.51

How does vert.x compare to spring?

@x80486 That's what I meant, I just wanted to have a way to avoid the overhead of deploying verticles, when swarm does that for me. I looked into other solutions, but it looks like the only one that's async is vert.x, except for ktor that's on it's way but still in beta... Microservices need to be small to be scaled and scheduled by docker swarm without wasting too much resources...

that's cool 🙂

I have set a route to serve uploaded image files

router.get("/file-uploads/*").handler(StaticHandler.create())

. Vert.X is failing to serve the files with this error message Resource not found, even though a correct image URL was provided.

Hey @dave08 it would be appreciated if u can share your code, it would help me understanding stuff

I opened an issue, did I understand properly? https://github.com/ktorio/ktor/issues/286

@eddy_wm I would advise you to run it in your own thread and not in Vert.x executeBlocking, executeBlocking is designed for method that blocks a fair amount of time (like reading a file or doing an HTTP GET)

BTW the

vertx-gradle-plugin

has no impact on that

Darn if I want older messages I have to pay. Are these slack messages being archived anywhere?

@asad.awadia Would this be any help to you? https://developers.redhat.com/promotions/building-reactive-microservices-in-java/

Pushed an example project using vert.x 4.5 with coroutines. Maybe someone's interested https://github.com/s1monw1/VertxProjectsManagement/tree/master/src/main/kotlin/de/swirtz/kotlinvertx/rest

So the

Thread.sleep

isn't blocking its suspending the coroutine?

I’d suggest using existing JDBC connection pool libraries, such as HikariCP. Unless vert.x has its own, I don’t know…