Hey guys. I’m rewriting my Spring app in ktor and I’m curious how to bind a function to multiple rows. My Spring code:

@PostMapping(value = ["success", "pending"])
fun successOrPending(request: WebRequest): String {
}

Ideally I’m looking for something like this:

post(listOf("success", "pending")) {
}

you could do this with shared handler for your routes

fun Route.myHandler(): Unit = TODO()
        
        route("/success", Post, Route::myHandler)
        route("/pending", Post, Route::myHandler)

or write interceptor for complex routing

Yep. That’s obvious. But since ktor is

unopinionated

, it shouldn’t force user to extract handler into a separate function.

Anyway. I made it like this:

suspend fun PipelineContext<Unit, ApplicationCall>.successOrPending() {
}
post("success") { successOrPending() }
post("pending") { successOrPending() }

you may try to do your own Route.post extension that supports paths as collection

Yep. Just realized this. Changed to:

fun <http://Route.post|Route.post>(paths: List<String>, body: PipelineInterceptor<Unit, ApplicationCall>) {
    paths.forEach { path ->
        <http://this.post|this.post>(path, body)
    }
}
post(listOf("success", "pending")) {
}

You are right. Since this function will be mostly called with literals, varargs will fit better. Thanks @orangy

Btw. Is there support for flash session attributes ?

Like in Spring MVC. You set them and they go away after first hit

Nope, no flash sessions. We had it in the roadmap, then didn’t have time to actually make them, and then nobody asked 🙂

Ok. I will implement them. Maybe if they will feel idiomatic to ktor I will issue a PR 🙂

Even if you don’t feel they are idiomatic, please make a PR 🙂 We can work from there and improve it. But please don’t forget tests, tests are mandatory.

I think the proper way is to see what changes should be made to

SessionTransport

or

SessionTracker

to make it possible, if any

For now I will hack them in ASAP, since I need them today. And then take a look how to refactor into a proper solution.

May be just setting cookie duration can help?

cookie<TestUserSession>(cookieName, sessionStorage) {
                    cookie.duration = Duration.ofSeconds(0)
                }

Ah, nope, sorry.

I see it as a separate session installation.

Main session may be persisted. And flash session is just in-memory and has some kind of interceptor that converts it to some kind of request parameter.

Hmm, what’s session transport in your case? Cookie? Or query-param?

Cookie with sessionId

Here is what I mean. Main session(SimpleSession) is persisted and FlashSession is not.

fun Application.sessionModule() {
    install(Sessions) {
        cookie<SimpleSession>(
                "JSESSION_ID",
                directorySessionStorage(File("../../.sessions"))) {
            cookie.path = "/"
        }
        cookie<FlashSession>(
                "FLASH_SESSION_ID") {
            cookie.path = "/"
        }
    }
}

yes, but how do you clean it on first receive?

Second

cookie

call install

SessionTrackerByValue

, which will serialize

FlashSession

and put the result in a cookie

Yes. You are right. I forgot

SessionStorageMemory()

Well, to clean on first route I may create interceptor that will look for

FlashSession

and move it to request parameters.

I’m thinking about something like this:

class FlashSessionTransport(private val transport: SessionTransport) : SessionTransport {
    companion object {
        private val flashSessionKey = AttributeKey<Boolean>("FlashSessionReceived")
    }

    override fun receive(call: ApplicationCall): String? = transport.receive(call)?.also {
        call.attributes.put(flashSessionKey, true)
    }

    override fun send(call: ApplicationCall, value: String) = if (call.attributes.getOrNull(flashSessionKey) == true)
        transport.clear(call)
    else
        transport.send(call, value)

    override fun clear(call: ApplicationCall) = transport.clear(call)

}

inline fun <S : Any> Sessions.Configuration.flash(name: String, sessionType: KClass<S>, block: CookieSessionBuilder<S>.() -> Unit) {
    val builder = CookieSessionBuilder(sessionType).apply(block)
    val transport = FlashSessionTransport(SessionTransportCookie(name, builder.cookie, builder.transformers))
    val tracker = SessionTrackerByValue(sessionType, builder.serializer)
    val provider = SessionProvider(name, sessionType, transport, tracker)
    register(provider)
}

and then use

flash

instead of

cookie

builder function

I didn’t try it, might have issues 🙂

Note that this assumes you have only one flash session configured. If you need more, you might need to pass

name

to

FlashSessionTransport

and then tweak storing attributes so that you can track each name separately.