Call remote tasks of service workspace #75
41
dataforge-distributed/build.gradle.kts
Normal file
@ -0,0 +1,41 @@
|
||||
plugins {
|
||||
id("ru.mipt.npm.gradle.mpp")
|
||||
}
|
||||
|
||||
kotlin {
|
||||
sourceSets {
|
||||
commonMain {
|
||||
dependencies {
|
||||
api(project(":dataforge-context"))
|
||||
api(project(":dataforge-data"))
|
||||
api(project(":dataforge-io"))
|
||||
api(project(":dataforge-workspace"))
|
||||
}
|
||||
}
|
||||
jvmMain {
|
||||
dependencies {
|
||||
// TODO include fat jar of lambdarpc
|
||||
api(files("lambdarpc-core-0.0.1.jar"))
|
||||
runtimeOnly("io.grpc:grpc-netty-shaded:1.44.0")
|
||||
api("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.0")
|
||||
api("io.grpc:grpc-protobuf:1.44.0")
|
||||
api("com.google.protobuf:protobuf-java-util:3.19.4")
|
||||
api("com.google.protobuf:protobuf-kotlin:3.19.4")
|
||||
api("io.grpc:grpc-kotlin-stub:1.2.1")
|
||||
api("org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.2")
|
||||
api("org.slf4j:slf4j-simple:1.7.36")
|
||||
api("io.github.microutils:kotlin-logging-jvm:2.1.21")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
kscience {
|
||||
useSerialization {
|
||||
json()
|
||||
}
|
||||
}
|
||||
|
||||
readme {
|
||||
maturity = ru.mipt.npm.gradle.Maturity.PROTOTYPE
|
||||
}
|
@ -0,0 +1,37 @@
|
||||
package space.kscience.dataforge.distributed
|
||||
|
||||
import io.lambdarpc.utils.Endpoint
|
||||
import space.kscience.dataforge.context.AbstractPlugin
|
||||
import space.kscience.dataforge.context.PluginTag
|
||||
import space.kscience.dataforge.names.Name
|
||||
import space.kscience.dataforge.workspace.Task
|
||||
import kotlin.reflect.KType
|
||||
|
||||
/**
|
||||
* Plugin that purpose is to communicate with remote plugins.
|
||||
* @param endpoint Endpoint of the remote plugin.
|
||||
*/
|
||||
public abstract class ClientWorkspacePlugin(endpoint: Endpoint) : AbstractPlugin() {
|
||||
|
||||
/**
|
||||
* Tag og the [ClientWorkspacePlugin] should be equal to the tag of the corresponding remote plugin.
|
||||
*/
|
||||
abstract override val tag: PluginTag
|
||||
|
||||
/**
|
||||
* Enumeration of names of remote tasks and their result types.
|
||||
*/
|
||||
public abstract val tasks: Map<Name, KType>
|
||||
|
||||
private val _tasks: Map<Name, Task<*>> by lazy {
|
||||
tasks.mapValues { (_, type) ->
|
||||
RemoteTask<Any>(endpoint, type)
|
||||
}
|
||||
}
|
||||
|
||||
override fun content(target: String): Map<Name, Any> =
|
||||
when (target) {
|
||||
Task.TYPE -> _tasks
|
||||
else -> emptyMap()
|
||||
}
|
||||
}
|
@ -1,4 +1,4 @@
|
||||
package space.kscience.dataforge.workspace.distributed
|
||||
package space.kscience.dataforge.distributed
|
||||
|
||||
import io.lambdarpc.dsl.ServiceDispatcher
|
||||
import io.lambdarpc.utils.Endpoint
|
@ -0,0 +1,81 @@
|
||||
|
||||
package space.kscience.dataforge.distributed
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import io.ktor.utils.io.core.*
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import io.lambdarpc.dsl.LibService
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import io.lambdarpc.dsl.def
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import io.lambdarpc.utils.Address
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import io.lambdarpc.utils.Port
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import io.lambdarpc.utils.toSid
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import kotlinx.coroutines.runBlocking
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.context.Context
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.context.Global
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.context.gather
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.data.DataSet
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.data.DataTree
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.distributed.serialization.DataSetCoder
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
I do not see, why we need it in the API on the server side the connection should be closeable, not the workspace. Maybe you should rename it to connection and remove inheritance from a workspace? I do not see, why we need it in the API on the server side the connection should be closeable, not the workspace. Maybe you should rename it to connection and remove inheritance from a workspace?
|
||||
import space.kscience.dataforge.distributed.serialization.NameCoder
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.distributed.serialization.SerializableDataSetAdapter
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.meta.Meta
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.names.Name
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.names.asName
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.workspace.Task
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.workspace.TaskResult
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.workspace.Workspace
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
import space.kscience.dataforge.workspace.wrapResult
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
/**
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
* Workspace that exposes its tasks for remote clients.
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
*/
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
public class ServiceWorkspace(
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
address: String = "localhost",
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
port: Int? = null,
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
override val context: Context = Global.buildContext("workspace".asName()),
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
data: DataSet<*> = runBlocking { DataTree<Any> {} },
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
override val targets: Map<String, Meta> = mapOf(),
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
) : Workspace, Closeable {
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
override val data: TaskResult<*> = wrapResult(data, Name.EMPTY, Meta.EMPTY)
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
override val tasks: Map<Name, Task<*>>
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
get() = context.gather(Task.TYPE)
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
private val service = LibService(serviceId, address, port) {
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
execute of { name ->
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
val res = produce(name, Meta.EMPTY)
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
SerializableDataSetAdapter(res)
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
}
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
}
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
/**
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
* Address this workspace is available on.
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
*/
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
public val address: Address = Address(address)
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
/**
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
* Port this workspace is available on.
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
*/
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
public val port: Port
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
get() = service.port
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
/**
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
* Start [ServiceWorkspace] as a service.
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
*/
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
public fun start(): Unit = service.start()
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
/**
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
* Await termination of the service.
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
*/
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
public fun awaitTermination(): Unit = service.awaitTermination()
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
/**
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
* Shutdown service.
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
*/
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
public fun shutdown(): Unit = service.shutdown()
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
override fun close(): Unit = service.shutdown()
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
public companion object {
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
internal val serviceId = "d41b95b1-828b-4444-8ff0-6f9c92a79246".toSid()
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
internal val execute by serviceId.def(NameCoder, DataSetCoder)
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
}
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
||||
}
|
||||
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now. DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming Need to think about better naming
Why not suspended? Why not suspended?
I thought about I thought about `WorkspaceNode` or `WorkerWorkspace`. There is also `DistributedWorkspace` but it is not truly distributed itself.
Also `ServiceWorkpace` is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so. Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
|
@ -0,0 +1,22 @@
|
||||
package space.kscience.dataforge.distributed.serialization
|
||||
|
||||
import io.lambdarpc.coding.Coder
|
||||
import io.lambdarpc.coding.CodingContext
|
||||
import io.lambdarpc.transport.grpc.Entity
|
||||
import io.lambdarpc.transport.serialization.Entity
|
||||
import io.lambdarpc.transport.serialization.RawData
|
||||
import java.nio.charset.Charset
|
||||
|
||||
internal object DataSetCoder : Coder<SerializableDataSet<Any>> {
|
||||
override fun decode(entity: Entity, context: CodingContext): SerializableDataSet<Any> {
|
||||
val string = entity.data.toString(Charset.defaultCharset())
|
||||
val prototype = DataSetPrototype.fromJson(string)
|
||||
return prototype.toDataSet()
|
||||
}
|
||||
|
||||
override fun encode(value: SerializableDataSet<Any>, context: CodingContext): Entity {
|
||||
val prototype = DataSetPrototype.of(value)
|
||||
val string = prototype.toJson()
|
||||
return Entity(RawData.copyFrom(string, Charset.defaultCharset()))
|
||||
}
|
||||
}
|
@ -0,0 +1,20 @@
|
||||
package space.kscience.dataforge.distributed.serialization
|
||||
|
||||
import io.lambdarpc.coding.Coder
|
||||
import io.lambdarpc.coding.CodingContext
|
||||
import io.lambdarpc.transport.grpc.Entity
|
||||
import io.lambdarpc.transport.serialization.Entity
|
||||
import io.lambdarpc.transport.serialization.RawData
|
||||
import space.kscience.dataforge.names.Name
|
||||
import java.nio.charset.Charset
|
||||
|
||||
internal object NameCoder : Coder<Name> {
|
||||
override fun decode(entity: Entity, context: CodingContext): Name {
|
||||
require(entity.hasData()) { "Entity should contain data" }
|
||||
val string = entity.data.toString(Charset.defaultCharset())
|
||||
return Name.parse(string)
|
||||
}
|
||||
|
||||
override fun encode(value: Name, context: CodingContext): Entity =
|
||||
Entity(RawData.copyFrom(value.toString(), Charset.defaultCharset()))
|
||||
}
|
@ -0,0 +1,16 @@
|
||||
package space.kscience.dataforge.distributed.serialization
|
||||
|
||||
import space.kscience.dataforge.data.DataSet
|
||||
import kotlin.reflect.KType
|
||||
|
||||
/**
|
||||
* Represents [DataSet] that should be initialized before usage.
|
||||
*/
|
||||
internal interface SerializableDataSet<T : Any> : DataSet<T> {
|
||||
fun finishDecoding(type: KType)
|
||||
}
|
||||
|
||||
internal class SerializableDataSetAdapter<T : Any>(dataSet: DataSet<T>) :
|
||||
SerializableDataSet<T>, DataSet<T> by dataSet {
|
||||
override fun finishDecoding(type: KType) = Unit
|
||||
}
|
@ -0,0 +1,56 @@
|
||||
There is existing class for that There is existing class for that
There is existing class for that There is existing class for that
|
||||
package space.kscience.dataforge.distributed.serialization
|
||||
There is existing class for that There is existing class for that
|
||||
|
||||
There is existing class for that There is existing class for that
|
||||
import kotlinx.coroutines.CompletableDeferred
|
||||
There is existing class for that There is existing class for that
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
There is existing class for that There is existing class for that
|
||||
import kotlinx.coroutines.Deferred
|
||||
There is existing class for that There is existing class for that
|
||||
import kotlinx.serialization.KSerializer
|
||||
There is existing class for that There is existing class for that
|
||||
import kotlinx.serialization.Serializable
|
||||
There is existing class for that There is existing class for that
|
||||
import kotlinx.serialization.json.Json
|
||||
There is existing class for that There is existing class for that
|
||||
import space.kscience.dataforge.data.Data
|
||||
There is existing class for that There is existing class for that
|
||||
import space.kscience.dataforge.data.Goal
|
||||
There is existing class for that There is existing class for that
|
||||
import space.kscience.dataforge.data.await
|
||||
There is existing class for that There is existing class for that
|
||||
import space.kscience.dataforge.meta.Meta
|
||||
There is existing class for that There is existing class for that
|
||||
import space.kscience.dataforge.meta.MetaSerializer
|
||||
There is existing class for that There is existing class for that
|
||||
import kotlin.reflect.KType
|
||||
There is existing class for that There is existing class for that
|
||||
|
||||
There is existing class for that There is existing class for that
|
||||
/**
|
||||
This is unusable. I believe that it should be something like this:
This is unusable. I believe that it should be something like this:
```kotlin
class SerializeableData<T>(val data: Data<T>, val serializer: KSerializer<T>): Data<T> by data
```
There is existing class for that There is existing class for that
Is it used somewhere? Is it used somewhere?
|
||||
* [Data] representation that is trivially serializable.
|
||||
There is existing class for that There is existing class for that
|
||||
*/
|
||||
There is existing class for that There is existing class for that
|
||||
@Serializable
|
||||
There is existing class for that There is existing class for that
|
||||
internal data class DataPrototype(
|
||||
There is existing class for that There is existing class for that
|
||||
val meta: String,
|
||||
There is existing class for that There is existing class for that
|
||||
val data: String,
|
||||
There is existing class for that There is existing class for that
|
||||
) {
|
||||
There is existing class for that There is existing class for that
|
||||
fun toData(type: KType): Data<Any> =
|
||||
There is existing class for that There is existing class for that
|
||||
SimpleData(
|
||||
There is existing class for that There is existing class for that
|
||||
type = type,
|
||||
There is existing class for that There is existing class for that
|
||||
meta = Json.decodeFromString(MetaSerializer, meta),
|
||||
There is existing class for that There is existing class for that
|
||||
data = Json.decodeFromString(kotlinx.serialization.serializer(type), data)!!
|
||||
There is existing class for that There is existing class for that
|
||||
)
|
||||
There is existing class for that There is existing class for that
|
||||
|
||||
There is existing class for that There is existing class for that
|
||||
companion object {
|
||||
There is existing class for that There is existing class for that
|
||||
suspend fun <T : Any> of(data: Data<T>, serializer: KSerializer<in T>): DataPrototype {
|
||||
There is existing class for that There is existing class for that
|
||||
val meta = Json.encodeToString(MetaSerializer, data.meta)
|
||||
There is existing class for that There is existing class for that
|
||||
val string = Json.encodeToString(serializer, data.await())
|
||||
There is existing class for that There is existing class for that
|
||||
return DataPrototype(meta, string)
|
||||
There is existing class for that There is existing class for that
|
||||
}
|
||||
There is existing class for that There is existing class for that
|
||||
}
|
||||
There is existing class for that There is existing class for that
|
||||
}
|
||||
There is existing class for that There is existing class for that
|
||||
|
||||
There is existing class for that There is existing class for that
|
||||
/**
|
||||
There is existing class for that There is existing class for that
|
||||
* Trivial [Data] implementation.
|
||||
There is existing class for that There is existing class for that
|
||||
*/
|
||||
There is existing class for that There is existing class for that
|
||||
private class SimpleData<T : Any>(
|
||||
There is existing class for that There is existing class for that
|
||||
override val type: KType,
|
||||
There is existing class for that There is existing class for that
|
||||
override val meta: Meta,
|
||||
There is existing class for that There is existing class for that
|
||||
val data: T,
|
||||
There is existing class for that There is existing class for that
|
||||
) : Data<T> {
|
||||
There is existing class for that There is existing class for that
|
||||
override val dependencies: Collection<Goal<*>>
|
||||
There is existing class for that There is existing class for that
|
||||
get() = emptyList()
|
||||
There is existing class for that There is existing class for that
|
||||
|
||||
There is existing class for that There is existing class for that
|
||||
override val deferred: Deferred<T>
|
||||
There is existing class for that There is existing class for that
|
||||
get() = CompletableDeferred(data)
|
||||
There is existing class for that There is existing class for that
|
||||
|
||||
There is existing class for that There is existing class for that
|
||||
override fun async(coroutineScope: CoroutineScope): Deferred<T> = deferred
|
||||
There is existing class for that There is existing class for that
|
||||
override fun reset() = Unit
|
||||
There is existing class for that There is existing class for that
|
||||
}
|
||||
There is existing class for that There is existing class for that
|
@ -0,0 +1,73 @@
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
package space.kscience.dataforge.distributed.serialization
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import kotlinx.coroutines.flow.asFlow
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import kotlinx.coroutines.flow.map
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import kotlinx.coroutines.flow.toList
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import kotlinx.coroutines.runBlocking
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import kotlinx.serialization.Serializable
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import kotlinx.serialization.json.Json
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import kotlinx.serialization.serializer
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import space.kscience.dataforge.data.Data
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import space.kscience.dataforge.data.DataSet
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import space.kscience.dataforge.data.NamedData
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import space.kscience.dataforge.data.component1
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import space.kscience.dataforge.data.component2
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import space.kscience.dataforge.names.Name
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
import kotlin.reflect.KType
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
/**
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
* [DataSet] representation that is trivially serializable.
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
*/
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
@Serializable
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
Do we need that? Do we need that?
|
||||
internal data class DataSetPrototype(val data: Map<String, DataPrototype>) {
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
fun toDataSet(): SerializableDataSet<Any> =
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
SerializableDataSetImpl(this)
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
fun toJson(): String = Json.encodeToString(serializer(), this)
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
companion object {
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
fun <T : Any> of(dataSet: DataSet<T>): DataSetPrototype = runBlocking {
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
val serializer = serializer(dataSet.dataType)
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
val map = mutableListOf<Pair<String, DataPrototype>>()
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
dataSet.flowData().map { (name, data) ->
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
name.toString() to DataPrototype.of(data, serializer)
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
}.toList(map)
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
DataSetPrototype(map.associate { it })
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
}
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
fun fromJson(string: String): DataSetPrototype = Json.decodeFromString(serializer(), string)
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
}
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
}
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
/**
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
* Trivial [SerializableDataSet] implementation.
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
*/
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
private class SerializableDataSetImpl(private val prototype: DataSetPrototype) : SerializableDataSet<Any> {
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
private lateinit var type: KType
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
private lateinit var data: Map<Name, Data<Any>>
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
override fun finishDecoding(type: KType) {
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
this.type = type
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
this.data = prototype.data
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
.mapKeys { (name, _) -> Name.of(name) }
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
.mapValues { (_, dataPrototype) -> dataPrototype.toData(type) }
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
}
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
override val dataType: KType
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
get() = type
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
override fun flowData(): Flow<NamedData<Any>> =
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
data.map { (name, data) -> SimpleNamedData(name, data) }.asFlow()
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
override suspend fun getData(name: Name): Data<Any>? = data[name]
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
/**
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
* Trivial named data implementation.
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
*/
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
private class SimpleNamedData(
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
override val name: Name,
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
override val data: Data<Any>,
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
) : NamedData<Any>, Data<Any> by data
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
||||
}
|
||||
Again, you do not need a separate structure. All you need is a generic DataSet with serializer. Again, you do not need a separate structure. All you need is a generic DataSet with serializer.
When When `ServiceWorkspace.execute` returns result to the client, it do not know yet about serializer for the `T`. Then `RemoteTask` uses serializer to deserialize DataSet from prototype.
|
@ -1,4 +1,4 @@
|
||||
package space.kscience.dataforge.workspace
|
||||
package space.kscience.dataforge.distributed
|
||||
|
||||
import io.lambdarpc.utils.Endpoint
|
||||
import kotlinx.coroutines.runBlocking
|
||||
@ -19,9 +19,11 @@ import space.kscience.dataforge.data.static
|
||||
import space.kscience.dataforge.meta.Meta
|
||||
import space.kscience.dataforge.names.Name
|
||||
import space.kscience.dataforge.names.asName
|
||||
import space.kscience.dataforge.workspace.distributed.ClientWorkspacePlugin
|
||||
import space.kscience.dataforge.workspace.distributed.ServiceWorkspace
|
||||
import space.kscience.dataforge.workspace.Workspace
|
||||
import space.kscience.dataforge.workspace.WorkspacePlugin
|
||||
import space.kscience.dataforge.workspace.task
|
||||
import kotlin.reflect.KClass
|
||||
import kotlin.reflect.KType
|
||||
import kotlin.reflect.typeOf
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
@ -46,11 +48,15 @@ private class MyPlugin : WorkspacePlugin() {
|
||||
}
|
||||
}
|
||||
|
||||
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
|
||||
MyPlugin.tag,
|
||||
endpoint,
|
||||
"task".asName() to typeOf<Int>()
|
||||
)
|
||||
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(endpoint) {
|
||||
override val tag: PluginTag
|
||||
get() = MyPlugin.tag
|
||||
|
||||
override val tasks: Map<Name, KType>
|
||||
get() = mapOf(
|
||||
"task".asName() to typeOf<Int>()
|
||||
)
|
||||
}
|
||||
|
||||
@TestInstance(TestInstance.Lifecycle.PER_CLASS)
|
||||
class ServiceWorkspaceTest {
|
@ -12,30 +12,9 @@ kotlin {
|
||||
api(project(":dataforge-io"))
|
||||
}
|
||||
}
|
||||
jvmMain {
|
||||
dependencies {
|
||||
// TODO include fat jar of lambdarpc
|
||||
api(files("lambdarpc-core-0.0.1.jar"))
|
||||
runtimeOnly("io.grpc:grpc-netty-shaded:1.44.0")
|
||||
api("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.6.0")
|
||||
api("io.grpc:grpc-protobuf:1.44.0")
|
||||
api("com.google.protobuf:protobuf-java-util:3.19.4")
|
||||
api("com.google.protobuf:protobuf-kotlin:3.19.4")
|
||||
api("io.grpc:grpc-kotlin-stub:1.2.1")
|
||||
api("org.jetbrains.kotlinx:kotlinx-serialization-json:1.3.2")
|
||||
api("org.slf4j:slf4j-simple:1.7.36")
|
||||
api("io.github.microutils:kotlin-logging-jvm:2.1.21")
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
kscience {
|
||||
useSerialization {
|
||||
json()
|
||||
}
|
||||
}
|
||||
|
||||
readme {
|
||||
maturity = ru.mipt.npm.gradle.Maturity.EXPERIMENTAL
|
||||
}
|
||||
}
|
||||
|
@ -1,31 +0,0 @@
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
package space.kscience.dataforge.workspace.distributed
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
import io.lambdarpc.utils.Endpoint
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
import space.kscience.dataforge.context.AbstractPlugin
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
import space.kscience.dataforge.context.PluginTag
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
import space.kscience.dataforge.names.Name
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
import space.kscience.dataforge.workspace.Task
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
import kotlin.reflect.KType
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
/**
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
* Plugin that purpose is to communicate with remote plugins.
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
* @param tag Tag og the [ClientWorkspacePlugin] should be equal to the tag of the corresponding remote plugin.
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
* @param endpoint Endpoint of the remote plugin.
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
* @param tasks Enumeration of names of remote tasks and their result types.
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
*/
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
public abstract class ClientWorkspacePlugin(
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
override val tag: PluginTag,
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
endpoint: Endpoint,
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
vararg tasks: Pair<Name, KType>,
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
) : AbstractPlugin() {
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
private val tasks: Map<Name, Task<*>> = tasks.associate { (name, type) ->
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
name to RemoteTask<Any>(endpoint, type)
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
}
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
override fun content(target: String): Map<Name, Any> =
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
when (target) {
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
Task.TYPE -> tasks
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
else -> emptyMap()
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
}
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
||||
}
|
||||
Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins. Can we avoid inheriting both client and server plugins for each workspace? Context configuration is more or less serializeable, so it is better to share only configuration, not duplicate plugins.
There is already WorkspacePlugin that does similar thing. There is already WorkspacePlugin that does similar thing.
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
KType is not serializable. Maybe it is possible to partially serialize remote plugin configuration, but I see no way to avoid a little bit of configuration:
```kotlin
private class RemoteMyPlugin(endpoint: Endpoint) : ClientWorkspacePlugin(
MyPlugin.tag,
endpoint,
"task".asName() to typeOf<Int>()
)
```
`WorkspacePlugin` is also a `TaskContainer`, which I did not want to. `ClientPlugin` is just a port to existing remote plugin and has no tasks locally.
|
@ -1,237 +0,0 @@
|
||||
Remove debug print Remove debug print
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
Why? Why?
There is existing one There is existing one
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
package space.kscience.dataforge.workspace.distributed
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import io.ktor.utils.io.core.*
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import io.lambdarpc.coding.Coder
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import io.lambdarpc.coding.CodingContext
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import io.lambdarpc.dsl.LibService
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import io.lambdarpc.dsl.def
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import io.lambdarpc.transport.grpc.Entity
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import io.lambdarpc.transport.serialization.Entity
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import io.lambdarpc.transport.serialization.RawData
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import io.lambdarpc.utils.Address
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import io.lambdarpc.utils.Port
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import io.lambdarpc.utils.toSid
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlinx.coroutines.CompletableDeferred
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlinx.coroutines.Deferred
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlinx.coroutines.flow.asFlow
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlinx.coroutines.flow.map
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlinx.coroutines.flow.toList
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlinx.coroutines.runBlocking
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlinx.serialization.KSerializer
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlinx.serialization.Serializable
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlinx.serialization.json.Json
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlinx.serialization.serializer
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.context.Context
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.context.Global
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.context.gather
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.data.Data
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.data.DataSet
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.data.DataTree
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.data.Goal
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.data.NamedData
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.data.await
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.data.component1
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.data.component2
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.meta.Meta
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.meta.MetaSerializer
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.names.Name
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.names.asName
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.workspace.Task
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.workspace.TaskResult
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.workspace.Workspace
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import space.kscience.dataforge.workspace.wrapResult
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import java.nio.charset.Charset
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
import kotlin.reflect.KType
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
/**
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
* Workspace that exposes its tasks for remote clients.
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
*/
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
public class ServiceWorkspace(
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
address: String = "localhost",
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
port: Int? = null,
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override val context: Context = Global.buildContext("workspace".asName()),
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
data: DataSet<*> = runBlocking { DataTree<Any> {} },
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override val targets: Map<String, Meta> = mapOf(),
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
) : Workspace, Closeable {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override val data: TaskResult<*> = wrapResult(data, Name.EMPTY, Meta.EMPTY)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override val tasks: Map<Name, Task<*>>
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
get() = context.gather(Task.TYPE)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
private val service = LibService(serviceId, address, port) {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
execute of { name ->
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val res = produce(name, Meta.EMPTY)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
LazyDecodableDataSetAdapter(res)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
/**
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
* Address this workspace is available on.
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
*/
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
public val address: Address = Address(address)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
/**
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
* Port this workspace is available on.
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
*/
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
public val port: Port
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
get() = service.port
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
/**
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
* Start [ServiceWorkspace] as a service.
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
*/
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
public fun start(): Unit = service.start()
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
/**
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
* Await termination of the service.
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
*/
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
public fun awaitTermination(): Unit = service.awaitTermination()
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
/**
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
* Shutdown service.
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
*/
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
public fun shutdown(): Unit = service.shutdown()
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override fun close(): Unit = service.shutdown()
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
public companion object {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
internal val serviceId = "d41b95b1-828b-4444-8ff0-6f9c92a79246".toSid()
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
internal val execute by serviceId.def(NameCoder, DataSetCoder)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
private object NameCoder : Coder<Name> {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override fun decode(entity: Entity, context: CodingContext): Name {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
require(entity.hasData()) { "Entity should contain data" }
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val string = entity.data.toString(Charset.defaultCharset())
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
return Name.parse(string)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override fun encode(value: Name, context: CodingContext): Entity =
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
Entity(RawData.copyFrom(value.toString(), Charset.defaultCharset()))
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
@Serializable
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
private data class DataPrototype(
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val meta: String,
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val data: String,
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
) {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
companion object {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
suspend fun <T : Any> of(data: Data<T>, serializer: KSerializer<in T>): DataPrototype {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val meta = Json.encodeToString(MetaSerializer, data.meta)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val string = Json.encodeToString(serializer, data.await())
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
return DataPrototype(meta, string)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
/**
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
* Data class that represents serializable [DataSet].
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
*/
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
@Serializable
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
private data class DataSetPrototype(
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val data: Map<String, DataPrototype>,
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
/**
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
* [DataSetPrototype] builder.
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
*/
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
private fun <T : Any> DataSet<T>.toPrototype(): DataSetPrototype = runBlocking {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val serializer = serializer(dataType)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val map = mutableListOf<Pair<String, DataPrototype>>()
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
flowData().map { (name, data) ->
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
name.toString() to DataPrototype.of(data, serializer)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}.toList(map)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
DataSetPrototype(map.associate { it })
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
/**
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
* Trivial [Data] implementation.
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
*/
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
private class SimpleData(
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override val type: KType,
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override val meta: Meta,
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val data: Any,
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
) : Data<Any> {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override val dependencies: Collection<Goal<*>>
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
get() = emptyList()
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override val deferred: Deferred<Any>
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
get() = CompletableDeferred(data)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override fun async(coroutineScope: CoroutineScope): Deferred<Any> = deferred
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override fun reset() = Unit
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
/**
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
* Trivial named data implementation.
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
*/
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
private class SimpleNamedData(
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override val name: Name,
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override val data: Data<Any>,
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
) : NamedData<Any>, Data<Any> by data
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
/**
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
* Represents [DataSet] that should be initialized before usage.
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
*/
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
internal interface LazyDecodableDataSet<T : Any> : DataSet<T> {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
fun finishDecoding(type: KType)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
private class LazyDecodableDataSetAdapter<T : Any>(val dataSet: DataSet<T>) :
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
LazyDecodableDataSet<T>, DataSet<T> by dataSet {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override fun finishDecoding(type: KType) = Unit
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
/**
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
* Trivial [LazyDecodableDataSet] implementation.
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
*/
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
private class SimpleDataSet(private val prototype: DataSetPrototype) : LazyDecodableDataSet<Any> {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
lateinit var type: KType
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
lateinit var data: Map<Name, Pair<Meta, Any>>
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override fun finishDecoding(type: KType) {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
this.type = type
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val serializer = serializer(type)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
this.data = prototype.data
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
.mapKeys { (name, _) -> Name.of(name) }
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
.mapValues { (_, pair) ->
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val (meta, data) = pair
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
Pair(
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
Json.decodeFromString(MetaSerializer, meta),
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
Json.decodeFromString(serializer, data)!!
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override val dataType: KType
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
get() = type
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override fun flowData(): Flow<NamedData<Any>> =
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
data.map { (name, pair) ->
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val (meta, data) = pair
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val wrapped = SimpleData(dataType, meta, data)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
SimpleNamedData(name, wrapped)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}.asFlow()
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override suspend fun getData(name: Name): Data<Any>? = data[name]?.let { (meta, data) ->
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
SimpleData(dataType, meta, data)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
private object DataSetCoder : Coder<LazyDecodableDataSet<Any>> {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override fun decode(entity: Entity, context: CodingContext): LazyDecodableDataSet<Any> {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val string = entity.data.toString(Charset.defaultCharset())
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val prototype = Json.decodeFromString(serializer<DataSetPrototype>(), string)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
return SimpleDataSet(prototype)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
override fun encode(value: LazyDecodableDataSet<Any>, context: CodingContext): Entity {
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val prototype = value.toPrototype()
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
val string = Json.encodeToString(serializer(), prototype)
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
return Entity(RawData.copyFrom(string, Charset.defaultCharset()))
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
||||
}
|
||||
Remove debug print Remove debug print
Better to pass Adress from outside instead of constructor initialization. Better to pass Adress from outside instead of constructor initialization.
Why? Why?
There is existing one There is existing one
I think that may be not a good idea to expose lambdarpc dependency I think that may be not a good idea to expose lambdarpc dependency
Just temporary hole Just temporary hole
Yes, but it is private for some reason Yes, but it is private for some reason
|
@ -22,5 +22,6 @@ include(
|
||||
":dataforge-context",
|
||||
":dataforge-data",
|
||||
":dataforge-workspace",
|
||||
":dataforge-scripting"
|
||||
)
|
||||
":dataforge-scripting",
|
||||
":dataforge-distributed",
|
||||
)
|
||||
|
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
DataTree builder will be non-suspending in the next version, but it should be possible to create it without suspending now.
Need to think about better naming
Need to think about better naming
Why not suspended?
Why not suspended?
I thought about
WorkspaceNode
orWorkerWorkspace
. There is alsoDistributedWorkspace
but it is not truly distributed itself.Also
ServiceWorkpace
is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.I thought about
WorkspaceNode
orWorkerWorkspace
. There is alsoDistributedWorkspace
but it is not truly distributed itself.Also
ServiceWorkpace
is good enought to my opinion. "Service" here means that this workspace should be run on some endpoint to be available.Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.
Because it is blocking in the google gRPC implementation. It can be made suspend and block separate thread but I do not see any reasons to do so.