Minor tweaks, switch to PostgreSQL for debuggigng purposes

src/main/kotlin/io/dico/parcels2/command/CommandAsync.kt

@@ -1,83 +0,0 @@
-package io.dico.parcels2.command
-
-import io.dico.dicore.command.CommandException
-import io.dico.dicore.command.CommandResult
-import io.dico.dicore.command.EMessageType
-import io.dico.dicore.command.ExecutionContext
-import io.dico.dicore.command.chat.IChatController
-import io.dico.parcels2.ParcelsPlugin
-import io.dico.parcels2.logger
-import kotlinx.coroutines.experimental.*
-import org.bukkit.command.CommandSender
-import kotlin.coroutines.experimental.Continuation
-import kotlin.coroutines.experimental.suspendCoroutine
-
-/*
- * Interface to implicitly access plugin by creating extension functions for it
- */
-interface HasPlugin {
-    val plugin: ParcelsPlugin
-}
-
-class CommandAsyncScope {
-
-    suspend fun <T> HasPlugin.awaitSynchronousTask(delay: Int = 0, task: () -> T): T {
-        return suspendCoroutine { cont: Continuation<T> ->
-            plugin.server.scheduler.runTaskLater(plugin, l@{
-                val result = try {
-                    task()
-                } catch (ex: CommandException) {
-                    cont.resumeWithException(ex)
-                    return@l
-                } catch (ex: Throwable) {
-                    cont.context.cancel(ex)
-                    return@l
-                }
-                cont.resume(result)
-            }, delay.toLong())
-        }
-    }
-
-    fun <T> HasPlugin.synchronousTask(delay: Int = 0, task: () -> T): Deferred<T> {
-        return async { awaitSynchronousTask(delay, task) }
-    }
-
-}
-
-fun <T : Any?> HasPlugin.delegateCommandAsync(context: ExecutionContext,
-                                              block: suspend CommandAsyncScope.() -> T) {
-
-    val job: Deferred<Any?> = async(/*context = plugin.storage.asyncDispatcher, */start = CoroutineStart.ATOMIC) {
-        CommandAsyncScope().block()
-    }
-
-    fun Job.invokeOnCompletionSynchronously(block: (Throwable?) -> Unit) = invokeOnCompletion {
-        plugin.server.scheduler.runTask(plugin) { block(it) }
-    }
-
-    job.invokeOnCompletionSynchronously l@{ exception: Throwable? ->
-        exception?.let {
-            context.address.chatController.handleCoroutineException(context.sender, context, it)
-            return@l
-        }
-
-        val result = job.getCompleted()
-        val message = when (result) {
-            is String -> result
-            is CommandResult -> result.message
-            else -> null
-        }
-
-        context.address.chatController.sendMessage(context.sender, EMessageType.RESULT, message)
-    }
-
-}
-
-fun IChatController.handleCoroutineException(sender: CommandSender, context: ExecutionContext, exception: Throwable) {
-    if (exception is CancellationException) {
-        sendMessage(sender, EMessageType.EXCEPTION, "The command was cancelled unexpectedly (see console)")
-        logger.warn("An asynchronously dispatched command was cancelled unexpectedly", exception)
-    } else {
-        handleException(sender, context, exception)
-    }
-}

src/main/kotlin/io/dico/parcels2/command/CommandRequirement.kt

@@ -19,44 +19,28 @@ import kotlin.reflect.jvm.kotlinFunction
 @Retention(AnnotationRetention.RUNTIME)
 annotation class ParcelRequire(val admin: Boolean = false, val owner: Boolean = false)
 
-sealed class BaseScope(private var _timeout: Int = 0) : ICommandSuspendReceiver {
-    override fun getTimeout() = _timeout
-    fun setTimeout(timeout: Int) {
-        _timeout = timeout
-    }
-}
+@Target(AnnotationTarget.FUNCTION)
+@Retention(AnnotationRetention.RUNTIME)
+annotation class SuspensionTimeout(val millis: Int)
 
-class SuspendOnlyScope : BaseScope()
-class ParcelScope(val world: ParcelWorld, val parcel: Parcel) : BaseScope()
-class WorldOnlyScope(val world: ParcelWorld) : BaseScope()
+open class WorldScope(val world: ParcelWorld) : ICommandReceiver
+open class ParcelScope(val parcel: Parcel) : WorldScope(parcel.world)
 
 fun getParcelCommandReceiver(worlds: Worlds, context: ExecutionContext, method: Method, cmdName: String): ICommandReceiver {
+    val player = context.sender as Player
     val function = method.kotlinFunction!!
     val receiverType = function.extensionReceiverParameter!!.type
-    logger.info("Receiver type: ${receiverType.javaType.typeName}")
-
     val require = function.findAnnotation<ParcelRequire>()
     val admin = require?.admin == true
     val owner = require?.owner == true
 
-    val player = context.sender as Player
-
     return when (receiverType.jvmErasure) {
-        ParcelScope::class -> worlds.getParcelRequired(player, admin = admin, own = owner).let {
-            ParcelScope(it.world, it)
-        }
-        WorldOnlyScope::class -> worlds.getWorldRequired(player, admin = admin).let {
-            WorldOnlyScope(it)
-        }
-        SuspendOnlyScope::class -> SuspendOnlyScope()
+        ParcelScope::class -> ParcelScope(worlds.getParcelRequired(player, admin, owner))
+        WorldScope::class -> WorldScope(worlds.getWorldRequired(player, admin))
         else -> throw InternalError("Invalid command receiver type")
-
     }
 }
 
-/*
- * Functions for checking
- */
 fun Worlds.getWorldRequired(player: Player, admin: Boolean = false): ParcelWorld {
     if (admin) Validate.isTrue(player.hasAdminManage, "You must have admin rights to use that command")
     return getWorld(player.world)

src/main/kotlin/io/dico/parcels2/command/ParcelCommands.kt

@@ -8,6 +8,7 @@ import io.dico.dicore.command.annotation.Desc
 import io.dico.dicore.command.annotation.RequireParameters
 import io.dico.parcels2.ParcelOwner
 import io.dico.parcels2.ParcelsPlugin
+import io.dico.parcels2.command.NamedParcelDefaultValue.FIRST_OWNED
 import io.dico.parcels2.logger
 import io.dico.parcels2.storage.getParcelBySerializedValue
 import io.dico.parcels2.util.hasParcelHomeOthers
@@ -34,7 +35,7 @@ class ParcelCommands(val plugin: ParcelsPlugin) : ICommandReceiver.Factory {
     @Desc("Finds the unclaimed parcel nearest to origin,",
         "and gives it to you",
         shortVersion = "sets you up with a fresh, unclaimed parcel")
-    suspend fun WorldOnlyScope.cmdAuto(player: Player): Any? {
+    suspend fun WorldScope.cmdAuto(player: Player): Any? {
         logger.info("cmdAuto thread before await: ${Thread.currentThread().name}")
         val numOwnedParcels = plugin.storage.getNumParcels(ParcelOwner(uuid = player.uuid)).await()
         logger.info("cmdAuto thread before await: ${Thread.currentThread().name}")
@@ -65,8 +66,9 @@ class ParcelCommands(val plugin: ParcelsPlugin) : ICommandReceiver.Factory {
         "more than one parcel",
         shortVersion = "teleports you to parcels")
     @RequireParameters(0)
-    suspend fun SuspendOnlyScope.cmdHome(player: Player, context: ExecutionContext,
-                                         @NamedParcelDefault(NamedParcelDefaultValue.FIRST_OWNED) target: NamedParcelTarget): Any? {
+    suspend fun cmdHome(player: Player,
+                        @NamedParcelDefault(FIRST_OWNED) target: NamedParcelTarget): Any?
+    {
         if (player !== target.player && !player.hasParcelHomeOthers) {
             error("You do not have permission to teleport to other people's parcels")
         }