chore: typoを修正

.github/workflows/pull-request-merge-check.yml

@@ -27,7 +27,7 @@ jobs:
       core: ${{ steps.filter.outputs.core }}
       mastodon: ${{ steps.filter.outputs.mastodon }}
       activitypub: ${{ steps.filter.outputs.ap }}
-      owl: $${{ steps.filter.outputs.owl }}
+      owl: ${{ steps.filter.outputs.owl }}
     steps:
       - name: Checkout
         uses: actions/checkout@v4
@@ -166,7 +166,8 @@ jobs:
           gradle-home-cache-cleanup: true
 
       - name: Build
-        run: ./owl/gradlew :owl:classes --no-daemon
+        working-directory: owl
+        run: ./gradlew :classes --no-daemon
 
   hideout-core-unit-test:
     needs:
@@ -311,7 +312,8 @@ jobs:
           gradle-home-cache-cleanup: true
 
       - name: Unit Test
-        run: ./owl/gradlew :owl:koverXmlReport
+        working-directory: owl
+        run: ./gradlew :koverXmlReport --rerun-tasks
 
       - name: JUnit Test Report
         uses: mikepenz/action-junit-report@v4
@@ -389,7 +391,8 @@ jobs:
 
       - name: owl Lint
         if: always()
-        run: ./owl/gradlew :owl:detektMain
+        working-directory: owl
+        run: ./gradlew :detektMain
 
       - name: Auto Commit
         if: ${{ always() }}

build.gradle.kts

@@ -52,6 +52,7 @@ repositories {
 dependencies {
     implementation("dev.usbharu:hideout-core:0.0.1")
     implementation("dev.usbharu:hideout-mastodon:1.0-SNAPSHOT")
+    implementation("dev.usbharu:hideout-activitypub:1.0-SNAPSHOT")
 }
 
 tasks.register("run") {

hideout-activitypub/build.gradle.kts

@@ -1,5 +1,9 @@
+import kotlinx.kover.gradle.plugin.dsl.CoverageUnit
+
 plugins {
-    kotlin("jvm") version "1.9.25"
+    alias(libs.plugins.kotlin.jvm)
+    alias(libs.plugins.detekt)
+    alias(libs.plugins.kover)
 }
 
 group = "dev.usbharu"
@@ -11,6 +15,7 @@ repositories {
 
 dependencies {
     testImplementation(kotlin("test"))
+    detektPlugins(libs.detekt.formatting)
 }
 
 tasks.test {
@@ -19,3 +24,92 @@ tasks.test {
 kotlin {
     jvmToolchain(21)
 }
+
+
+configurations {
+    matching { it.name == "detekt" }.all {
+        resolutionStrategy.eachDependency {
+            if (requested.group == "org.jetbrains.kotlin") {
+                useVersion(io.gitlab.arturbosch.detekt.getSupportedKotlinVersion())
+            }
+        }
+    }
+    all {
+        exclude("org.apache.logging.log4j", "log4j-slf4j2-impl")
+    }
+}
+
+tasks {
+    withType<io.gitlab.arturbosch.detekt.Detekt> {
+        exclude("**/generated/**")
+        setSource("src/main/kotlin")
+        exclude("build/")
+        configureEach {
+            exclude("**/org/koin/ksp/generated/**", "**/generated/**")
+        }
+    }
+    withType<io.gitlab.arturbosch.detekt.DetektCreateBaselineTask>() {
+        configureEach {
+            exclude("**/org/koin/ksp/generated/**", "**/generated/**")
+        }
+    }
+    withType<Test> {
+        useJUnitPlatform()
+    }
+}
+
+
+project.gradle.taskGraph.whenReady {
+    if (this.hasTask(":koverGenerateArtifact")) {
+        val task = this.allTasks.find { it.name == "test" }
+        val verificationTask = task as VerificationTask
+        verificationTask.ignoreFailures = true
+    }
+}
+
+detekt {
+    parallel = true
+    config.setFrom(files("../detekt.yml"))
+    buildUponDefaultConfig = true
+    basePath = "${rootDir.absolutePath}/src/main/kotlin"
+    autoCorrect = true
+}
+
+kover {
+    currentProject {
+        sources {
+
+
+        }
+    }
+
+    reports {
+        verify {
+            rule {
+                bound {
+                    minValue = 50
+                    coverageUnits = CoverageUnit.INSTRUCTION
+                }
+            }
+        }
+        total {
+            xml {
+                title = "Hideout ActivityPub"
+                xmlFile = file("$buildDir/reports/kover/hideout-activitypub.xml")
+            }
+        }
+        filters {
+            excludes {
+                annotatedBy("org.springframework.context.annotation.Configuration")
+                annotatedBy("org.springframework.boot.context.properties.ConfigurationProperties")
+                packages(
+                    "dev.usbharu.hideout.controller.mastodon.generated",
+                    "dev.usbharu.hideout.domain.mastodon.model.generated"
+                )
+                packages("org.springframework")
+                packages("org.jetbrains")
+            }
+        }
+
+    }
+}

hideout-activitypub/settings.gradle.kts

@@ -3,3 +3,14 @@ plugins {
 }
 rootProject.name = "hideout-activitypub"
 
+dependencyResolutionManagement {
+    repositories {
+        mavenCentral()
+    }
+
+    versionCatalogs {
+        create("libs") {
+            from(files("../libs.versions.toml"))
+        }
+    }
+}

owl/build.gradle.kts

@@ -1,6 +1,10 @@
+import kotlinx.kover.gradle.plugin.dsl.CoverageUnit
+
 plugins {
     alias(libs.plugins.kotlin.jvm)
     id("maven-publish")
+    alias(libs.plugins.kover)
+    alias(libs.plugins.detekt)
 }
 
 
@@ -27,6 +31,8 @@ subprojects {
     apply {
         plugin("org.jetbrains.kotlin.jvm")
         plugin("maven-publish")
+        plugin(rootProject.libs.plugins.kover.get().pluginId)
+        plugin(rootProject.libs.plugins.detekt.get().pluginId)
     }
     kotlin {
         jvmToolchain(21)
@@ -35,13 +41,43 @@ subprojects {
     dependencies {
         implementation("org.slf4j:slf4j-api:2.0.15")
         testImplementation("org.junit.jupiter:junit-jupiter:5.10.3")
-
+        detektPlugins(rootProject.libs.detekt.formatting)
 
     }
 
-    tasks.test {
+    detekt {
+        parallel = true
+        config.setFrom(files("$rootDir/../detekt.yml"))
+        buildUponDefaultConfig = true
+        basePath = "${projectDir}/src/main/kotlin"
+        autoCorrect = true
+    }
+
+    project.gradle.taskGraph.whenReady {
+        if (this.hasTask(":koverGenerateArtifact")) {
+            val task = this.allTasks.find { it.name == "test" }
+            val verificationTask = task as VerificationTask
+            verificationTask.ignoreFailures = true
+        }
+    }
+    tasks {
+        withType<io.gitlab.arturbosch.detekt.Detekt> {
+            exclude("**/generated/**")
+            setSource("src/main/kotlin")
+            exclude("build/")
+            configureEach {
+                exclude("**/org/koin/ksp/generated/**", "**/generated/**")
+            }
+        }
+        withType<io.gitlab.arturbosch.detekt.DetektCreateBaselineTask>() {
+            configureEach {
+                exclude("**/org/koin/ksp/generated/**", "**/generated/**")
+            }
+        }
+        withType<Test> {
             useJUnitPlatform()
         }
+    }
 
     publishing {
         repositories {
@@ -70,3 +106,62 @@ subprojects {
         }
     }
 }
+
+dependencies {
+    kover(project(":owl-broker"))
+    kover(project(":owl-broker:owl-broker-mongodb"))
+    kover(project(":owl-common"))
+    kover(project(":owl-common:owl-common-serialize-jackson"))
+    kover(project(":owl-consumer"))
+    kover(project(":owl-producer"))
+    kover(project(":owl-producer:owl-producer-api"))
+    kover(project(":owl-producer:owl-producer-default"))
+    kover(project(":owl-producer:owl-producer-embedded"))
+}
+
+detekt {
+    parallel = true
+    config.setFrom(files("../detekt.yml"))
+    buildUponDefaultConfig = true
+    basePath = "${projectDir}/src/main/kotlin"
+    autoCorrect = true
+}
+
+project.gradle.taskGraph.whenReady {
+    if (this.hasTask(":koverGenerateArtifact")) {
+        val task = this.allTasks.find { it.name == "test" }
+        val verificationTask = task as VerificationTask
+        verificationTask.ignoreFailures = true
+    }
+}
+
+kover {
+    currentProject {
+        sources {
+            excludedSourceSets.addAll("grpc", "grpckt")
+        }
+    }
+    reports {
+        verify {
+            rule {
+                bound {
+                    minValue = 50
+                    coverageUnits = CoverageUnit.INSTRUCTION
+                }
+            }
+        }
+        total {
+            xml {
+                title = "Owl"
+                xmlFile = file("$buildDir/reports/kover/owl.xml")
+            }
+            filters {
+                excludes {
+                    packages("dev.usbharu.owl.generated")
+                }
+            }
+        }
+
+
+    }
+}

owl/gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.10.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

owl/owl-broker/build.gradle.kts

@@ -35,7 +35,7 @@ protobuf {
             artifact = libs.protoc.gen.grpc.java.get().toString()
         }
         create("grpckt") {
-            artifact = libs.protoc.gen.grpc.kotlin.get().toString() + "jdk8@jar"
+            artifact = libs.protoc.gen.grpc.kotlin.get().toString() + ":jdk8@jar"
         }
     }
     generateProtoTasks {

owl/owl-broker/owl-broker-mongodb/src/main/kotlin/dev/usbharu/owl/broker/mongodb/MongoModuleContext.kt

@@ -32,7 +32,6 @@ import org.koin.dsl.module
 
 class MongoModuleContext : ModuleContext {
     override fun module(): Module {
-
         return module {
             single {
                 val clientSettings =
@@ -47,7 +46,6 @@ class MongoModuleContext : ModuleContext {
                         )
                         .uuidRepresentation(UuidRepresentation.STANDARD).build()
 
-
                 MongoClient.create(clientSettings)
                     .getDatabase(System.getProperty("owl.broker.mongo.database", "mongo-test"))
             }

owl/owl-broker/owl-broker-mongodb/src/main/kotlin/dev/usbharu/owl/broker/mongodb/MongodbConsumerRepository.kt

@@ -33,7 +33,11 @@ class MongodbConsumerRepository(database: MongoDatabase) : ConsumerRepository {
 
     private val collection = database.getCollection<ConsumerMongodb>("consumers")
     override suspend fun save(consumer: Consumer): Consumer = withContext(Dispatchers.IO) {
-        collection.replaceOne(Filters.eq("_id", consumer.id.toString()), ConsumerMongodb.of(consumer), ReplaceOptions().upsert(true))
+        collection.replaceOne(
+            Filters.eq("_id", consumer.id.toString()),
+            ConsumerMongodb.of(consumer),
+            ReplaceOptions().upsert(true)
+        )
         return@withContext consumer
     }
 
@@ -53,9 +57,13 @@ data class ConsumerMongodb(
 
     fun toConsumer(): Consumer {
         return Consumer(
-            UUID.fromString(id), name, hostname, tasks
+            UUID.fromString(id),
+            name,
+            hostname,
+            tasks
         )
     }
+
     companion object {
         fun of(consumer: Consumer): ConsumerMongodb {
             return ConsumerMongodb(

owl/owl-broker/owl-broker-mongodb/src/main/kotlin/dev/usbharu/owl/broker/mongodb/MongodbQueuedTaskRepository.kt

@@ -48,7 +48,8 @@ class MongodbQueuedTaskRepository(
     override suspend fun save(queuedTask: QueuedTask): QueuedTask {
         withContext(Dispatchers.IO) {
             collection.replaceOne(
-                eq("_id", queuedTask.task.id.toString()), QueuedTaskMongodb.of(propertySerializerFactory, queuedTask),
+                eq("_id", queuedTask.task.id.toString()),
+                QueuedTaskMongodb.of(propertySerializerFactory, queuedTask),
                 ReplaceOptions().upsert(true)
             )
         }
@@ -57,7 +58,6 @@ class MongodbQueuedTaskRepository(
 
     override suspend fun findByTaskIdAndAssignedConsumerIsNullAndUpdate(id: UUID, update: QueuedTask): QueuedTask {
         return withContext(Dispatchers.IO) {
-
             val findOneAndUpdate = collection.findOneAndUpdate(
                 and(
                     eq("_id", id.toString()),
@@ -155,14 +155,14 @@ data class QueuedTaskMongodb(
         companion object {
             fun of(propertySerializerFactory: PropertySerializerFactory, task: Task): TaskMongodb {
                 return TaskMongodb(
-                    task.name,
+                    name = task.name,
-                    task.id.toString(),
+                    id = task.id.toString(),
-                    task.publishProducerId.toString(),
+                    publishProducerId = task.publishProducerId.toString(),
-                    task.publishedAt,
+                    publishedAt = task.publishedAt,
-                    task.nextRetry,
+                    nextRetry = task.nextRetry,
-                    task.completedAt,
+                    completedAt = task.completedAt,
-                    task.attempt,
+                    attempt = task.attempt,
-                    PropertySerializeUtils.serialize(propertySerializerFactory, task.properties)
+                    properties = PropertySerializeUtils.serialize(propertySerializerFactory, task.properties)
                 )
             }
         }
@@ -171,15 +171,15 @@ data class QueuedTaskMongodb(
     companion object {
         fun of(propertySerializerFactory: PropertySerializerFactory, queuedTask: QueuedTask): QueuedTaskMongodb {
             return QueuedTaskMongodb(
-                queuedTask.task.id.toString(),
+                id = queuedTask.task.id.toString(),
-                TaskMongodb.of(propertySerializerFactory, queuedTask.task),
+                task = TaskMongodb.of(propertySerializerFactory, queuedTask.task),
-                queuedTask.attempt,
+                attempt = queuedTask.attempt,
-                queuedTask.queuedAt,
+                queuedAt = queuedTask.queuedAt,
-                queuedTask.priority,
+                priority = queuedTask.priority,
-                queuedTask.isActive,
+                isActive = queuedTask.isActive,
-                queuedTask.timeoutAt,
+                timeoutAt = queuedTask.timeoutAt,
-                queuedTask.assignedConsumer?.toString(),
+                assignedConsumer = queuedTask.assignedConsumer?.toString(),
-                queuedTask.assignedAt
+                assignedAt = queuedTask.assignedAt
             )
         }
     }

owl/owl-broker/owl-broker-mongodb/src/main/kotlin/dev/usbharu/owl/broker/mongodb/MongodbTaskRepository.kt

@@ -36,27 +36,29 @@ import org.bson.codecs.pojo.annotations.BsonRepresentation
 import java.time.Instant
 import java.util.*
 
-
 class MongodbTaskRepository(database: MongoDatabase, private val propertySerializerFactory: PropertySerializerFactory) :
     TaskRepository {
 
     private val collection = database.getCollection<TaskMongodb>("tasks")
     override suspend fun save(task: Task): Task = withContext(Dispatchers.IO) {
         collection.replaceOne(
-            Filters.eq("_id", task.id.toString()), TaskMongodb.of(propertySerializerFactory, task),
+            Filters.eq("_id", task.id.toString()),
+            TaskMongodb.of(propertySerializerFactory, task),
             ReplaceOptions().upsert(true)
         )
         return@withContext task
     }
 
     override suspend fun saveAll(tasks: List<Task>): Unit = withContext(Dispatchers.IO) {
-        collection.bulkWrite(tasks.map {
+        collection.bulkWrite(
+            tasks.map {
                 ReplaceOneModel(
                     Filters.eq(it.id.toString()),
                     TaskMongodb.of(propertySerializerFactory, it),
                     ReplaceOptions().upsert(true)
                 )
-        })
+            }
+        )
     }
 
     override fun findByNextRetryBeforeAndCompletedAtIsNull(timestamp: Instant): Flow<Task> {
@@ -75,12 +77,13 @@ class MongodbTaskRepository(database: MongoDatabase, private val propertySeriali
 
     override suspend fun findByIdAndUpdate(id: UUID, task: Task) {
         collection.replaceOne(
-            Filters.eq("_id", task.id.toString()), TaskMongodb.of(propertySerializerFactory, task),
+            Filters.eq("_id", task.id.toString()),
+            TaskMongodb.of(propertySerializerFactory, task),
             ReplaceOptions().upsert(false)
         )
     }
 
-    override suspend fun findByPublishProducerIdAndCompletedAtIsNotNull(publishProducerId: UUID): Flow<Task> {
+    override fun findByPublishProducerIdAndCompletedAtIsNotNull(publishProducerId: UUID): Flow<Task> {
         return collection
             .find(Filters.eq(TaskMongodb::publishProducerId.name, publishProducerId.toString()))
             .map { it.toTask(propertySerializerFactory) }
@@ -116,14 +119,14 @@ data class TaskMongodb(
     companion object {
         fun of(propertySerializerFactory: PropertySerializerFactory, task: Task): TaskMongodb {
             return TaskMongodb(
-                task.name,
+                name = task.name,
-                task.id.toString(),
+                id = task.id.toString(),
-                task.publishProducerId.toString(),
+                publishProducerId = task.publishProducerId.toString(),
-                task.publishedAt,
+                publishedAt = task.publishedAt,
-                task.nextRetry,
+                nextRetry = task.nextRetry,
-                task.completedAt,
+                completedAt = task.completedAt,
-                task.attempt,
+                attempt = task.attempt,
-                PropertySerializeUtils.serialize(propertySerializerFactory, task.properties)
+                properties = PropertySerializeUtils.serialize(propertySerializerFactory, task.properties)
             )
         }
     }

owl/owl-broker/owl-broker-mongodb/src/main/kotlin/dev/usbharu/owl/broker/mongodb/MongodbTaskResultRepository.kt

@@ -41,14 +41,17 @@ class MongodbTaskResultRepository(
     private val collection = database.getCollection<TaskResultMongodb>("task_results")
     override suspend fun save(taskResult: TaskResult): TaskResult = withContext(Dispatchers.IO) {
         collection.replaceOne(
-            Filters.eq(taskResult.id.toString()), TaskResultMongodb.of(propertySerializerFactory, taskResult),
+            Filters.eq(taskResult.id.toString()),
+            TaskResultMongodb.of(propertySerializerFactory, taskResult),
             ReplaceOptions().upsert(true)
         )
         return@withContext taskResult
     }
 
     override fun findByTaskId(id: UUID): Flow<TaskResult> {
-        return collection.find(Filters.eq(id.toString())).map { it.toTaskResult(propertySerializerFactory) }.flowOn(Dispatchers.IO)
+        return collection.find(
+            Filters.eq(id.toString())
+        ).map { it.toTaskResult(propertySerializerFactory) }.flowOn(Dispatchers.IO)
     }
 }
 
@@ -65,27 +68,25 @@ data class TaskResultMongodb(
 
     fun toTaskResult(propertySerializerFactory: PropertySerializerFactory): TaskResult {
         return TaskResult(
-            UUID.fromString(id),
+            id = UUID.fromString(id),
-            UUID.fromString(taskId),
+            taskId = UUID.fromString(taskId),
-            success,
+            success = success,
-            attempt,
+            attempt = attempt,
-            PropertySerializeUtils.deserialize(propertySerializerFactory, result),
+            result = PropertySerializeUtils.deserialize(propertySerializerFactory, result),
-            message
+            message = message
         )
     }
 
     companion object {
         fun of(propertySerializerFactory: PropertySerializerFactory, taskResult: TaskResult): TaskResultMongodb {
             return TaskResultMongodb(
-                taskResult.id.toString(),
+                id = taskResult.id.toString(),
-                taskResult.taskId.toString(),
+                taskId = taskResult.taskId.toString(),
-                taskResult.success,
+                success = taskResult.success,
-                taskResult.attempt,
+                attempt = taskResult.attempt,
-                PropertySerializeUtils.serialize(propertySerializerFactory, taskResult.result),
+                result = PropertySerializeUtils.serialize(propertySerializerFactory, taskResult.result),
-                taskResult.message
+                message = taskResult.message
             )
-
+        }
-        }
-
     }
 }

owl/owl-broker/owl-broker-mongodb/src/test/kotlin/dev/usbharu/owl/broker/mongodb/MongodbConsumerRepositoryTest.kt

@@ -7,12 +7,14 @@ import dev.usbharu.owl.broker.domain.model.consumer.Consumer
 import kotlinx.coroutines.runBlocking
 import org.bson.UuidRepresentation
 import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
 import java.util.*
 
 
 class MongodbConsumerRepositoryTest {
     @Test
+    @Disabled
     fun name() {
 
         val clientSettings =

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/Main.kt

@@ -90,7 +90,6 @@ fun main() {
 
     logger.info("Use module name: {}", moduleContext)
 
-
     val koin = startKoin {
         printLogger()
 
@@ -98,7 +97,6 @@ fun main() {
             single<RetryPolicyFactory> {
                 DefaultRetryPolicyFactory(mapOf("" to ExponentialRetryPolicy()))
             }
-
         }
         modules(mainModule, module, moduleContext.module())
     }

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/ModuleContext.kt

@@ -23,7 +23,5 @@ interface ModuleContext {
 }
 
 data object EmptyModuleContext : ModuleContext {
-    override fun module(): Module {
+    override fun module(): Module = org.koin.dsl.module { }
-        return org.koin.dsl.module { }
-    }
 }

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/OwlBrokerApplication.kt

@@ -64,5 +64,4 @@ class OwlBrokerApplication(
     fun stop() {
         server.shutdown()
     }
-
 }

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/domain/model/task/TaskRepository.kt

@@ -31,5 +31,5 @@ interface TaskRepository {
 
     suspend fun findByIdAndUpdate(id: UUID, task: Task)
 
-    suspend fun findByPublishProducerIdAndCompletedAtIsNotNull(publishProducerId:UUID):Flow<Task>
+    fun findByPublishProducerIdAndCompletedAtIsNotNull(publishProducerId: UUID): Flow<Task>
 }

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/external/GrpcExtension.kt

@@ -17,7 +17,7 @@
 package dev.usbharu.owl.broker.external
 
 import com.google.protobuf.Timestamp
-import dev.usbharu.owl.Uuid
+import dev.usbharu.owl.generated.Uuid
 import java.time.Instant
 import java.util.*
 

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/interfaces/grpc/AssignmentTaskService.kt

@@ -16,14 +16,13 @@
 
 package dev.usbharu.owl.broker.interfaces.grpc
 
-
-import dev.usbharu.owl.AssignmentTaskServiceGrpcKt
-import dev.usbharu.owl.Task
 import dev.usbharu.owl.broker.external.toTimestamp
 import dev.usbharu.owl.broker.external.toUUID
 import dev.usbharu.owl.broker.service.QueuedTaskAssigner
 import dev.usbharu.owl.common.property.PropertySerializeUtils
 import dev.usbharu.owl.common.property.PropertySerializerFactory
+import dev.usbharu.owl.generated.AssignmentTaskServiceGrpcKt
+import dev.usbharu.owl.generated.Task
 import io.grpc.Status
 import io.grpc.StatusException
 import kotlinx.coroutines.flow.Flow
@@ -33,7 +32,6 @@ import org.slf4j.LoggerFactory
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 
-
 class AssignmentTaskService(
     coroutineContext: CoroutineContext = EmptyCoroutineContext,
     private val queuedTaskAssigner: QueuedTaskAssigner,
@@ -42,7 +40,6 @@ class AssignmentTaskService(
     AssignmentTaskServiceGrpcKt.AssignmentTaskServiceCoroutineImplBase(coroutineContext) {
 
     override fun ready(requests: Flow<Task.ReadyRequest>): Flow<Task.TaskRequest> {
-
         return try {
             requests
                 .flatMapMerge {

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/interfaces/grpc/DefinitionTaskService.kt

@@ -17,25 +17,28 @@
 package dev.usbharu.owl.broker.interfaces.grpc
 
 import com.google.protobuf.Empty
-import dev.usbharu.owl.DefinitionTask
-import dev.usbharu.owl.DefinitionTask.TaskDefined
-import dev.usbharu.owl.DefinitionTaskServiceGrpcKt.DefinitionTaskServiceCoroutineImplBase
 import dev.usbharu.owl.broker.domain.model.taskdefinition.TaskDefinition
 import dev.usbharu.owl.broker.service.RegisterTaskService
+import dev.usbharu.owl.generated.DefinitionTask
+import dev.usbharu.owl.generated.DefinitionTask.TaskDefined
+import dev.usbharu.owl.generated.DefinitionTaskServiceGrpcKt.DefinitionTaskServiceCoroutineImplBase
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 
-class DefinitionTaskService(coroutineContext: CoroutineContext = EmptyCoroutineContext,private val registerTaskService: RegisterTaskService) :
+class DefinitionTaskService(
+    coroutineContext: CoroutineContext = EmptyCoroutineContext,
+    private val registerTaskService: RegisterTaskService
+) :
     DefinitionTaskServiceCoroutineImplBase(coroutineContext) {
     override suspend fun register(request: DefinitionTask.TaskDefinition): TaskDefined {
         registerTaskService.registerTask(
             TaskDefinition(
-                request.name,
+                name = request.name,
-                request.priority,
+                priority = request.priority,
-                request.maxRetry,
+                maxRetry = request.maxRetry,
-                request.timeoutMilli,
+                timeoutMilli = request.timeoutMilli,
-                request.propertyDefinitionHash,
+                propertyDefinitionHash = request.propertyDefinitionHash,
-                request.retryPolicy
+                retryPolicy = request.retryPolicy
             )
         )
         return TaskDefined

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/interfaces/grpc/ProducerService.kt

@@ -16,24 +16,26 @@
 
 package dev.usbharu.owl.broker.interfaces.grpc
 
-import dev.usbharu.owl.ProducerOuterClass
-import dev.usbharu.owl.ProducerServiceGrpcKt.ProducerServiceCoroutineImplBase
 import dev.usbharu.owl.broker.external.toUUID
 import dev.usbharu.owl.broker.service.ProducerService
 import dev.usbharu.owl.broker.service.RegisterProducerRequest
+import dev.usbharu.owl.generated.ProducerOuterClass
+import dev.usbharu.owl.generated.ProducerServiceGrpcKt.ProducerServiceCoroutineImplBase
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 
-
 class ProducerService(
     coroutineContext: CoroutineContext = EmptyCoroutineContext,
     private val producerService: ProducerService
 ) :
     ProducerServiceCoroutineImplBase(coroutineContext) {
-    override suspend fun registerProducer(request: ProducerOuterClass.Producer): ProducerOuterClass.RegisterProducerResponse {
+    override suspend fun registerProducer(
+        request: ProducerOuterClass.Producer
+    ): ProducerOuterClass.RegisterProducerResponse {
         val registerProducer = producerService.registerProducer(
             RegisterProducerRequest(
-                request.name, request.hostname
+                request.name,
+                request.hostname
             )
         )
         return ProducerOuterClass.RegisterProducerResponse.newBuilder().setId(registerProducer.toUUID()).build()

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/interfaces/grpc/SubscribeTaskService.kt

@@ -16,11 +16,11 @@
 
 package dev.usbharu.owl.broker.interfaces.grpc
 
-import dev.usbharu.owl.Consumer
-import dev.usbharu.owl.SubscribeTaskServiceGrpcKt.SubscribeTaskServiceCoroutineImplBase
 import dev.usbharu.owl.broker.external.toUUID
 import dev.usbharu.owl.broker.service.ConsumerService
 import dev.usbharu.owl.broker.service.RegisterConsumerRequest
+import dev.usbharu.owl.generated.Consumer
+import dev.usbharu.owl.generated.SubscribeTaskServiceGrpcKt.SubscribeTaskServiceCoroutineImplBase
 import kotlin.coroutines.CoroutineContext
 import kotlin.coroutines.EmptyCoroutineContext
 

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/interfaces/grpc/TaskPublishService.kt

@@ -16,15 +16,15 @@
 
 package dev.usbharu.owl.broker.interfaces.grpc
 
-import dev.usbharu.owl.PublishTaskOuterClass
-import dev.usbharu.owl.PublishTaskOuterClass.PublishedTask
-import dev.usbharu.owl.PublishTaskOuterClass.PublishedTasks
-import dev.usbharu.owl.TaskPublishServiceGrpcKt.TaskPublishServiceCoroutineImplBase
 import dev.usbharu.owl.broker.external.toUUID
 import dev.usbharu.owl.broker.service.PublishTask
 import dev.usbharu.owl.broker.service.TaskPublishService
 import dev.usbharu.owl.common.property.PropertySerializeUtils
 import dev.usbharu.owl.common.property.PropertySerializerFactory
+import dev.usbharu.owl.generated.PublishTaskOuterClass
+import dev.usbharu.owl.generated.PublishTaskOuterClass.PublishedTask
+import dev.usbharu.owl.generated.PublishTaskOuterClass.PublishedTasks
+import dev.usbharu.owl.generated.TaskPublishServiceGrpcKt.TaskPublishServiceCoroutineImplBase
 import io.grpc.Status
 import io.grpc.StatusException
 import org.slf4j.LoggerFactory
@@ -39,13 +39,9 @@ class TaskPublishService(
     TaskPublishServiceCoroutineImplBase(coroutineContext) {
 
     override suspend fun publishTask(request: PublishTaskOuterClass.PublishTask): PublishedTask {
-
         logger.warn("aaaaaaaaaaa")
 
-
-
         return try {
-
             val publishedTask = taskPublishService.publishTask(
                 PublishTask(
                     request.name,
@@ -61,7 +57,6 @@ class TaskPublishService(
     }
 
     override suspend fun publishTasks(request: PublishTaskOuterClass.PublishTasks): PublishedTasks {
-
         val tasks = request.propertiesArrayList.map {
             PublishTask(
                 request.name,

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/interfaces/grpc/TaskResultService.kt

@@ -17,13 +17,13 @@
 package dev.usbharu.owl.broker.interfaces.grpc
 
 import com.google.protobuf.Empty
-import dev.usbharu.owl.TaskResultOuterClass
-import dev.usbharu.owl.TaskResultServiceGrpcKt
 import dev.usbharu.owl.broker.domain.model.taskresult.TaskResult
 import dev.usbharu.owl.broker.external.toUUID
 import dev.usbharu.owl.broker.service.TaskManagementService
 import dev.usbharu.owl.common.property.PropertySerializeUtils
 import dev.usbharu.owl.common.property.PropertySerializerFactory
+import dev.usbharu.owl.generated.TaskResultOuterClass
+import dev.usbharu.owl.generated.TaskResultServiceGrpcKt
 import io.grpc.Status
 import io.grpc.StatusException
 import kotlinx.coroutines.CancellationException

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/interfaces/grpc/TaskResultSubscribeService.kt

@@ -16,11 +16,11 @@
 
 package dev.usbharu.owl.broker.interfaces.grpc
 
-import dev.usbharu.owl.*
 import dev.usbharu.owl.broker.external.toUUID
 import dev.usbharu.owl.broker.service.TaskManagementService
 import dev.usbharu.owl.common.property.PropertySerializeUtils
 import dev.usbharu.owl.common.property.PropertySerializerFactory
+import dev.usbharu.owl.generated.*
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
 import kotlin.coroutines.CoroutineContext
@@ -41,7 +41,8 @@ class TaskResultSubscribeService(
                     name = it.name
                     attempt = it.attempt
                     success = it.success
-                    results.addAll(it.results.map {
+                    results.addAll(
+                        it.results.map {
                             taskResult {
                                 id = it.taskId.toUUID()
                                 success = it.success
@@ -49,7 +50,8 @@ class TaskResultSubscribeService(
                                 result.putAll(PropertySerializeUtils.serialize(propertySerializerFactory, it.result))
                                 message = it.message
                             }
-                    })
+                        }
+                    )
                 }
             }
     }

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/service/AssignQueuedTaskDecider.kt

@@ -42,7 +42,5 @@ class AssignQueuedTaskDeciderImpl(
                 ).take(numberOfConcurrent)
             )
         }
-
     }
-
 }

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/service/ProducerService.kt

@@ -26,10 +26,8 @@ interface ProducerService {
     suspend fun registerProducer(producer: RegisterProducerRequest): UUID
 }
 
-
 class ProducerServiceImpl(private val producerRepository: ProducerRepository) : ProducerService {
     override suspend fun registerProducer(producer: RegisterProducerRequest): UUID {
-
         val id = UUID.randomUUID()
 
         val saveProducer = Producer(

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/service/QueueScanner.kt

@@ -29,19 +29,14 @@ interface QueueScanner {
     fun startScan(): Flow<QueuedTask>
 }
 
-
 class QueueScannerImpl(private val queueStore: QueueStore) : QueueScanner {
-    override fun startScan(): Flow<QueuedTask> {
+    override fun startScan(): Flow<QueuedTask> = flow {
-        return flow {
         while (currentCoroutineContext().isActive) {
             emitAll(scanQueue())
             delay(1000)
         }
     }
-    }
-
-    private fun scanQueue(): Flow<QueuedTask> {
-        return queueStore.findByQueuedAtBeforeAndIsActiveIsTrue(Instant.now().minusSeconds(10))
-    }
 
+    private fun scanQueue(): Flow<QueuedTask> =
+        queueStore.findByQueuedAtBeforeAndIsActiveIsTrue(Instant.now().minusSeconds(10))
 }

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/service/QueueStore.kt

@@ -32,33 +32,24 @@ interface QueueStore {
     fun findByQueuedAtBeforeAndIsActiveIsTrue(instant: Instant): Flow<QueuedTask>
 }
 
-
 class QueueStoreImpl(private val queuedTaskRepository: QueuedTaskRepository) : QueueStore {
     override suspend fun enqueue(queuedTask: QueuedTask) {
         queuedTaskRepository.save(queuedTask)
     }
 
-    override suspend fun enqueueAll(queuedTaskList: List<QueuedTask>) {
+    override suspend fun enqueueAll(queuedTaskList: List<QueuedTask>) = queuedTaskList.forEach { enqueue(it) }
-        queuedTaskList.forEach { enqueue(it) }
-    }
 
     override suspend fun dequeue(queuedTask: QueuedTask) {
         queuedTaskRepository.findByTaskIdAndAssignedConsumerIsNullAndUpdate(queuedTask.task.id, queuedTask)
     }
 
-    override suspend fun dequeueAll(queuedTaskList: List<QueuedTask>) {
+    override suspend fun dequeueAll(queuedTaskList: List<QueuedTask>) = queuedTaskList.forEach { dequeue(it) }
-        return queuedTaskList.forEach { dequeue(it) }
-    }
 
     override fun findByTaskNameInAndIsActiveIsTrueAndOrderByPriority(
         tasks: List<String>,
         limit: Int
-    ): Flow<QueuedTask> {
+    ): Flow<QueuedTask> = queuedTaskRepository.findByTaskNameInAndIsActiveIsTrueAndOrderByPriority(tasks, limit)
-        return queuedTaskRepository.findByTaskNameInAndIsActiveIsTrueAndOrderByPriority(tasks, limit)
-    }
-
-    override fun findByQueuedAtBeforeAndIsActiveIsTrue(instant: Instant): Flow<QueuedTask> {
-        return queuedTaskRepository.findByQueuedAtBeforeAndIsActiveIsTrue(instant)
-    }
 
+    override fun findByQueuedAtBeforeAndIsActiveIsTrue(instant: Instant): Flow<QueuedTask> =
+        queuedTaskRepository.findByQueuedAtBeforeAndIsActiveIsTrue(instant)
 }

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/service/QueuedTaskAssigner.kt

@@ -27,7 +27,6 @@ interface QueuedTaskAssigner {
     fun ready(consumerId: UUID, numberOfConcurrent: Int): Flow<QueuedTask>
 }
 
-
 class QueuedTaskAssignerImpl(
     private val taskManagementService: TaskManagementService,
     private val queueStore: QueueStore
@@ -49,7 +48,6 @@ class QueuedTaskAssignerImpl(
 
     private suspend fun assignTask(queuedTask: QueuedTask, consumerId: UUID): QueuedTask? {
         return try {
-
             val assignedTaskQueue =
                 queuedTask.copy(assignedConsumer = consumerId, assignedAt = Instant.now(), isActive = false)
             logger.trace(

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/service/RegisterTaskService.kt

@@ -27,14 +27,15 @@ interface RegisterTaskService {
     suspend fun unregisterTask(name: String)
 }
 
-
 class RegisterTaskServiceImpl(private val taskDefinitionRepository: TaskDefinitionRepository) : RegisterTaskService {
     override suspend fun registerTask(taskDefinition: TaskDefinition) {
         val definedTask = taskDefinitionRepository.findByName(taskDefinition.name)
         if (definedTask != null) {
             logger.debug("Task already defined. name: ${taskDefinition.name}")
             if (taskDefinition.propertyDefinitionHash != definedTask.propertyDefinitionHash) {
-                throw IncompatibleTaskException("Task ${taskDefinition.name} has already been defined, and the parameters are incompatible.")
+                throw IncompatibleTaskException(
+                    "Task ${taskDefinition.name} has already been defined, and the parameters are incompatible."
+                )
             }
             return
         }

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/service/TaskManagementService.kt

@@ -31,7 +31,6 @@ import org.slf4j.LoggerFactory
 import java.time.Instant
 import java.util.*
 
-
 interface TaskManagementService {
 
     suspend fun startManagement(coroutineScope: CoroutineScope)
@@ -75,13 +74,11 @@ class TaskManagementServiceImpl(
         }
     }
 
-
     override fun findAssignableTask(consumerId: UUID, numberOfConcurrent: Int): Flow<QueuedTask> {
         return assignQueuedTaskDecider.findAssignableQueue(consumerId, numberOfConcurrent)
     }
 
     private suspend fun enqueueTask(task: Task): QueuedTask {
-
         val definedTask = taskDefinitionRepository.findByName(task.name)
             ?: throw TaskNotRegisterException("Task ${task.name} not definition.")
 
@@ -113,7 +110,6 @@ class TaskManagementServiceImpl(
 
         queueStore.dequeue(timeoutQueue)
 
-
         val task = taskRepository.findById(timeoutQueue.task.id)
             ?: throw RecordNotFoundException("Task not found. id: ${timeoutQueue.task.id}")
         val copy = task.copy(attempt = timeoutQueue.attempt)
@@ -148,12 +144,10 @@ class TaskManagementServiceImpl(
             taskResult.taskId,
             task.copy(completedAt = completedAt, attempt = taskResult.attempt)
         )
-
     }
 
     override fun subscribeResult(producerId: UUID): Flow<TaskResults> {
         return flow {
-
             while (currentCoroutineContext().isActive) {
                 taskRepository
                     .findByPublishProducerIdAndCompletedAtIsNotNull(producerId)
@@ -163,7 +157,7 @@ class TaskManagementServiceImpl(
                             TaskResults(
                                 it.name,
                                 it.id,
-                                results.any { it.success },
+                                results.any { taskResult -> taskResult.success },
                                 it.attempt,
                                 results
                             )
@@ -171,9 +165,7 @@ class TaskManagementServiceImpl(
                     }
                 delay(500)
             }
-
         }
-
     }
 
     companion object {

owl/owl-broker/src/main/kotlin/dev/usbharu/owl/broker/service/TaskPublishService.kt

@@ -78,7 +78,6 @@ class TaskPublishServiceImpl(
     }
 
     override suspend fun publishTasks(list: List<PublishTask>): List<PublishedTask> {
-
         val first = list.first()
 
         val definition = taskDefinitionRepository.findByName(first.name)
@@ -90,14 +89,14 @@ class TaskPublishServiceImpl(
 
         val tasks = list.map {
             Task(
-                it.name,
+                name = it.name,
-                UUID.randomUUID(),
+                id = UUID.randomUUID(),
-                first.producerId,
+                publishProducerId = first.producerId,
-                published,
+                publishedAt = published,
-                nextRetry,
+                nextRetry = nextRetry,
-                null,
+                completedAt = null,
-                0,
+                attempt = 0,
-                it.properties
+                properties = it.properties
             )
         }
 

owl/owl-broker/src/main/proto/consumer.proto

@@ -1,7 +1,7 @@
 syntax = "proto3";
 import "uuid.proto";
 
-option java_package = "dev.usbharu.owl";
+option java_package = "dev.usbharu.owl.generated";
 
 message SubscribeTaskRequest {
   string name = 1;

owl/owl-broker/src/main/proto/definition_task.proto

@@ -1,6 +1,6 @@
 syntax = "proto3";
 
-option java_package = "dev.usbharu.owl";
+option java_package = "dev.usbharu.owl.generated";
 
 import "google/protobuf/empty.proto";
 import "uuid.proto";

owl/owl-broker/src/main/proto/producer.proto

@@ -2,7 +2,7 @@ syntax = "proto3";
 
 import "uuid.proto";
 
-option java_package = "dev.usbharu.owl";
+option java_package = "dev.usbharu.owl.generated";
 
 message Producer {
   string name = 1;

owl/owl-broker/src/main/proto/property.proto

@@ -2,7 +2,7 @@ syntax = "proto3";
 
 import "google/protobuf/empty.proto";
 
-option java_package = "dev.usbharu.owl";
+option java_package = "dev.usbharu.owl.generated";
 
 message Property{
   oneof value {

owl/owl-broker/src/main/proto/publish_task.proto

@@ -4,7 +4,7 @@ import "google/protobuf/timestamp.proto";
 
 import "uuid.proto";
 
-option java_package = "dev.usbharu.owl";
+option java_package = "dev.usbharu.owl.generated";
 
 
 message PublishTask {

owl/owl-broker/src/main/proto/task.proto

@@ -3,7 +3,7 @@ import "uuid.proto";
 import "google/protobuf/timestamp.proto";
 import "property.proto";
 
-option java_package = "dev.usbharu.owl";
+option java_package = "dev.usbharu.owl.generated";
 
 message ReadyRequest {
   int32 number_of_concurrent = 1;

owl/owl-broker/src/main/proto/task_result.proto

@@ -3,7 +3,7 @@ import "uuid.proto";
 import "google/protobuf/empty.proto";
 import "property.proto";
 
-option java_package = "dev.usbharu.owl";
+option java_package = "dev.usbharu.owl.generated";
 
 message TaskResult {
   UUID id = 1;

owl/owl-broker/src/main/proto/task_result_producer.proto

@@ -2,7 +2,7 @@ syntax = "proto3";
 import "uuid.proto";
 import "task_result.proto";
 
-option java_package = "dev.usbharu.owl";
+option java_package = "dev.usbharu.owl.generated";
 
 message TaskResults {
   string name = 1;

owl/owl-broker/src/main/proto/uuid.proto

@@ -1,6 +1,6 @@
 syntax = "proto3";
 
-option java_package = "dev.usbharu.owl";
+option java_package = "dev.usbharu.owl.generated";
 
 message UUID {
   uint64 most_significant_uuid_bits = 1;

owl/owl-common/owl-common-serialize-jackson/src/main/kotlin/dev/usbharu/owl/common/property/ObjectPropertyValue.kt

@@ -45,6 +45,5 @@ class ObjectPropertySerializer(private val objectMapper: ObjectMapper) : Propert
                 Class.forName(string.substringAfter("jackson:").substringBefore(":"))
             )
         )
-
     }
 }

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/ReflectionUtils.kt

@@ -23,4 +23,7 @@ val Class<*>.allFields: List<Field>
         superclass.allFields + declaredFields
     } else {
         declaredFields.toList()
-    }.map { it.trySetAccessible();it }
+    }.map {
+        it.trySetAccessible()
+        it
+    }

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/property/BooleanPropertyValue.kt

@@ -15,19 +15,12 @@ class BooleanPropertyValue(override val value: Boolean) : PropertyValue<Boolean>
  *
  */
 class BooleanPropertySerializer : PropertySerializer<Boolean> {
-    override fun isSupported(propertyValue: PropertyValue<*>): Boolean {
+    override fun isSupported(propertyValue: PropertyValue<*>): Boolean = propertyValue.value is Boolean
-        return propertyValue.value is Boolean
-    }
 
-    override fun isSupported(string: String): Boolean {
+    override fun isSupported(string: String): Boolean = string.startsWith("bool:")
-        return string.startsWith("bool:")
-    }
 
-    override fun serialize(propertyValue: PropertyValue<*>): String {
+    override fun serialize(propertyValue: PropertyValue<*>): String = "bool:" + propertyValue.value.toString()
-        return "bool:" + propertyValue.value.toString()
-    }
 
-    override fun deserialize(string: String): PropertyValue<Boolean> {
+    override fun deserialize(string: String): PropertyValue<Boolean> =
-        return BooleanPropertyValue(string.replace("bool:", "").toBoolean())
+        BooleanPropertyValue(string.replace("bool:", "").toBoolean())
-    }
 }

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/property/CustomPropertySerializerFactory.kt

@@ -23,12 +23,9 @@ package dev.usbharu.owl.common.property
  */
 open class CustomPropertySerializerFactory(private val propertySerializers: Set<PropertySerializer<*>>) :
     PropertySerializerFactory {
-    override fun <T> factory(propertyValue: PropertyValue<T>): PropertySerializer<T> {
+    override fun <T> factory(propertyValue: PropertyValue<T>): PropertySerializer<T> =
-        return propertySerializers.firstOrNull { it.isSupported(propertyValue) } as PropertySerializer<T>?
+        propertySerializers.firstOrNull { it.isSupported(propertyValue) } as PropertySerializer<T>?
             ?: throw IllegalArgumentException("PropertySerializer not found: $propertyValue")
-    }
 
-    override fun factory(string: String): PropertySerializer<*> {
+    override fun factory(string: String): PropertySerializer<*> = propertySerializers.first { it.isSupported(string) }
-        return propertySerializers.first { it.isSupported(string) }
-    }
 }

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/property/DoublePropertyValue.kt

@@ -15,19 +15,12 @@ class DoublePropertyValue(override val value: Double) : PropertyValue<Double>()
  *
  */
 class DoublePropertySerializer : PropertySerializer<Double> {
-    override fun isSupported(propertyValue: PropertyValue<*>): Boolean {
+    override fun isSupported(propertyValue: PropertyValue<*>): Boolean = propertyValue.value is Double
-        return propertyValue.value is Double
-    }
 
-    override fun isSupported(string: String): Boolean {
+    override fun isSupported(string: String): Boolean = string.startsWith("double:")
-        return string.startsWith("double:")
-    }
 
-    override fun serialize(propertyValue: PropertyValue<*>): String {
+    override fun serialize(propertyValue: PropertyValue<*>): String = "double:" + propertyValue.value.toString()
-        return "double:" + propertyValue.value.toString()
-    }
 
-    override fun deserialize(string: String): PropertyValue<Double> {
+    override fun deserialize(string: String): PropertyValue<Double> =
-        return DoublePropertyValue(string.replace("double:", "").toDouble())
+        DoublePropertyValue(string.replace("double:", "").toDouble())
-    }
 }

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/property/FloatPropertyValue.kt

@@ -26,19 +26,12 @@ class FloatPropertyValue(override val value: Float) : PropertyValue<Float>() {
  *
  */
 class FloatPropertySerializer : PropertySerializer<Float> {
-    override fun isSupported(propertyValue: PropertyValue<*>): Boolean {
+    override fun isSupported(propertyValue: PropertyValue<*>): Boolean = propertyValue.value is Float
-        return propertyValue.value is Float
-    }
 
-    override fun isSupported(string: String): Boolean {
+    override fun isSupported(string: String): Boolean = string.startsWith("float:")
-        return string.startsWith("float:")
-    }
 
-    override fun serialize(propertyValue: PropertyValue<*>): String {
+    override fun serialize(propertyValue: PropertyValue<*>): String = "float:" + propertyValue.value.toString()
-        return "float:" + propertyValue.value.toString()
-    }
 
-    override fun deserialize(string: String): PropertyValue<Float> {
+    override fun deserialize(string: String): PropertyValue<Float> =
-        return FloatPropertyValue(string.replace("float:", "").toFloat())
+        FloatPropertyValue(string.replace("float:", "").toFloat())
-    }
 }

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/property/IntegerPropertyValue.kt

@@ -31,19 +31,12 @@ class IntegerPropertyValue(override val value: Int) : PropertyValue<Int>() {
  *
  */
 class IntegerPropertySerializer : PropertySerializer<Int> {
-    override fun isSupported(propertyValue: PropertyValue<*>): Boolean {
+    override fun isSupported(propertyValue: PropertyValue<*>): Boolean = propertyValue.value is Int
-        return propertyValue.value is Int
-    }
 
-    override fun isSupported(string: String): Boolean {
+    override fun isSupported(string: String): Boolean = string.startsWith("int32:")
-        return string.startsWith("int32:")
-    }
 
-    override fun serialize(propertyValue: PropertyValue<*>): String {
+    override fun serialize(propertyValue: PropertyValue<*>): String = "int32:" + propertyValue.value.toString()
-        return "int32:" + propertyValue.value.toString()
-    }
 
-    override fun deserialize(string: String): PropertyValue<Int> {
+    override fun deserialize(string: String): PropertyValue<Int> =
-        return IntegerPropertyValue(string.replace("int32:", "").toInt())
+        IntegerPropertyValue(string.replace("int32:", "").toInt())
-    }
 }

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/property/LongPropertyValue.kt

@@ -27,19 +27,12 @@ class LongPropertyValue(override val value: Long) : PropertyValue<Long>() {
  *
  */
 class LongPropertySerializer : PropertySerializer<Long> {
-    override fun isSupported(propertyValue: PropertyValue<*>): Boolean {
+    override fun isSupported(propertyValue: PropertyValue<*>): Boolean = propertyValue.value is Long
-        return propertyValue.value is Long
-    }
 
-    override fun isSupported(string: String): Boolean {
+    override fun isSupported(string: String): Boolean = string.startsWith("int64:")
-        return string.startsWith("int64:")
-    }
 
-    override fun serialize(propertyValue: PropertyValue<*>): String {
+    override fun serialize(propertyValue: PropertyValue<*>): String = "int64:" + propertyValue.value.toString()
-        return "int64:" + propertyValue.value.toString()
-    }
 
-    override fun deserialize(string: String): PropertyValue<Long> {
+    override fun deserialize(string: String): PropertyValue<Long> =
-        return LongPropertyValue(string.replace("int64:", "").toLong())
+        LongPropertyValue(string.replace("int64:", "").toLong())
-    }
 }

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/property/PropertyValue.kt

@@ -31,9 +31,5 @@ abstract class PropertyValue<T> {
      * プロパティの型
      */
     abstract val type: PropertyType
-    override fun toString(): String {
+    override fun toString(): String = "PropertyValue(value=$value, type=$type)"
-        return "PropertyValue(value=$value, type=$type)"
-    }
-
-
 }

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/property/StringPropertyValue.kt

@@ -15,19 +15,11 @@ class StringPropertyValue(override val value: String) : PropertyValue<String>()
  *
  */
 class StringPropertyValueSerializer : PropertySerializer<String> {
-    override fun isSupported(propertyValue: PropertyValue<*>): Boolean {
+    override fun isSupported(propertyValue: PropertyValue<*>): Boolean = propertyValue.value is String
-        return propertyValue.value is String
-    }
 
-    override fun isSupported(string: String): Boolean {
+    override fun isSupported(string: String): Boolean = string.startsWith("str:")
-        return string.startsWith("str:")
-    }
 
-    override fun serialize(propertyValue: PropertyValue<*>): String {
+    override fun serialize(propertyValue: PropertyValue<*>): String = "str:" + propertyValue.value
-        return "str:" + propertyValue.value
-    }
 
-    override fun deserialize(string: String): PropertyValue<String> {
+    override fun deserialize(string: String): PropertyValue<String> = StringPropertyValue(string.replace("str:", ""))
-        return StringPropertyValue(string.replace("str:", ""))
-    }
 }

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/retry/ExponentialRetryPolicy.kt

@@ -13,5 +13,4 @@ import kotlin.math.roundToLong
 class ExponentialRetryPolicy(private val firstRetrySeconds: Int = 30) : RetryPolicy {
     override fun nextRetry(now: Instant, attempt: Int): Instant =
         now.plusSeconds(firstRetrySeconds.times((2.0).pow(attempt).roundToLong()) - firstRetrySeconds)
-
 }

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/retry/RetryPolicyFactory.kt

@@ -16,7 +16,6 @@
 
 package dev.usbharu.owl.common.retry
 
-
 import org.slf4j.LoggerFactory
 
 interface RetryPolicyFactory {
@@ -24,9 +23,7 @@ interface RetryPolicyFactory {
 }
 
 class DefaultRetryPolicyFactory(private val map: Map<String, RetryPolicy>) : RetryPolicyFactory {
-    override fun factory(name: String): RetryPolicy {
+    override fun factory(name: String): RetryPolicy = map[name] ?: throwException(name)
-        return map[name] ?: throwException(name)
-    }
 
     private fun throwException(name: String): Nothing {
         logger.warn("RetryPolicy not found. name: {}", name)

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/task/PropertyDefinition.kt

@@ -36,6 +36,4 @@ class PropertyDefinition(val map: Map<String, PropertyType>) : Map<String, Prope
         map.map { it.key + it.value.name }.joinToString("").map { hash *= it.code * 31 }
         return hash
     }
-
-
 }

owl/owl-common/src/main/kotlin/dev/usbharu/owl/common/task/TaskDefinition.kt

@@ -107,7 +107,6 @@ interface TaskDefinition<T : Task> {
      * @return デシリアライズされたタスク
      */
     fun deserialize(value: Map<String, PropertyValue<*>>): T {
-
         val task = try {
             type.getDeclaredConstructor().newInstance()
         } catch (e: Exception) {

owl/owl-consumer/build.gradle.kts

@@ -33,7 +33,7 @@ protobuf {
             artifact = libs.protoc.gen.grpc.java.get().toString()
         }
         create("grpckt") {
-            artifact = libs.protoc.gen.grpc.kotlin.get().toString() + "jdk8@jar"
+            artifact = libs.protoc.gen.grpc.kotlin.get().toString() + ":jdk8@jar"
         }
     }
     generateProtoTasks {

owl/owl-consumer/src/main/kotlin/dev/usbharu/owl/consumer/AbstractTaskRunner.kt

@@ -29,5 +29,4 @@ abstract class AbstractTaskRunner<T : Task, D : TaskDefinition<T>>(private val t
     }
 
     abstract suspend fun typedRun(typedParam: T, taskRequest: TaskRequest): TaskResult
-
 }

owl/owl-consumer/src/main/kotlin/dev/usbharu/owl/consumer/Consumer.kt

@@ -16,10 +16,10 @@
 
 package dev.usbharu.owl.consumer
 
-import dev.usbharu.owl.*
-import dev.usbharu.owl.Uuid.UUID
 import dev.usbharu.owl.common.property.PropertySerializeUtils
 import dev.usbharu.owl.common.property.PropertySerializerFactory
+import dev.usbharu.owl.generated.*
+import dev.usbharu.owl.generated.Uuid.UUID
 import kotlinx.coroutines.*
 import kotlinx.coroutines.flow.*
 import org.slf4j.LoggerFactory
@@ -66,11 +66,13 @@ class Consumer(
     suspend fun init(name: String, hostname: String) {
         logger.info("Initialize Consumer name: {} hostname: {}", name, hostname)
         logger.debug("Registered Tasks: {}", runnerMap.keys)
-        consumerId = subscribeTaskStub.subscribeTask(subscribeTaskRequest {
+        consumerId = subscribeTaskStub.subscribeTask(
+            subscribeTaskRequest {
                 this.name = name
                 this.hostname = hostname
                 this.tasks.addAll(runnerMap.keys)
-        }).id
+            }
+        ).id
         logger.info("Success initialize consumer. ConsumerID: {}", consumerId)
     }
 
@@ -84,11 +86,14 @@ class Consumer(
             while (isActive) {
                 try {
                     taskResultStub
-                        .tasKResult(flow {
+                        .tasKResult(
+                            flow {
                                 assignmentTaskStub
-                                .ready(flow {
+                                    .ready(
+                                        flow {
                                             requestTask()
-                                }).onEach {
+                                        }
+                                    ).onEach {
                                         logger.info("Start Task name: {} id: {}", it.name, it.id)
                                         processing.update { it + 1 }
 
@@ -101,7 +106,10 @@ class Consumer(
                                                         it.id.leastSignificantUuidBits
                                                     ),
                                                     it.attempt,
-                                                Instant.ofEpochSecond(it.queuedAt.seconds, it.queuedAt.nanos.toLong()),
+                                                    Instant.ofEpochSecond(
+                                                        it.queuedAt.seconds,
+                                                        it.queuedAt.nanos.toLong()
+                                                    ),
                                                     PropertySerializeUtils.deserialize(
                                                         propertySerializerFactory,
                                                         it.propertiesMap
@@ -109,17 +117,20 @@ class Consumer(
                                                 )
                                             )
 
-                                        emit(taskResult {
+                                            emit(
+                                                taskResult {
                                                     this.success = taskResult.success
                                                     this.attempt = it.attempt
                                                     this.id = it.id
                                                     this.result.putAll(
                                                         PropertySerializeUtils.serialize(
-                                                    propertySerializerFactory, taskResult.result
+                                                            propertySerializerFactory,
+                                                            taskResult.result
                                                         )
                                                     )
                                                     this.message = taskResult.message
-                                        })
+                                                }
+                                            )
                                             logger.info(
                                                 "Success execute task. name: {} success: {}",
                                                 it.name,
@@ -128,21 +139,25 @@ class Consumer(
                                             logger.debug("TRACE RESULT {}", taskResult)
                                         } catch (e: CancellationException) {
                                             logger.warn("Cancelled execute task.", e)
-                                        emit(taskResult {
+                                            emit(
+                                                taskResult {
                                                     this.success = false
                                                     this.attempt = it.attempt
                                                     this.id = it.id
                                                     this.message = e.localizedMessage
-                                        })
+                                                }
+                                            )
                                             throw e
                                         } catch (e: Exception) {
                                             logger.warn("Failed execute task. name: {} id: {}", it.name, it.id, e)
-                                        emit(taskResult {
+                                            emit(
+                                                taskResult {
                                                     this.success = false
                                                     this.attempt = it.attempt
                                                     this.id = it.id
                                                     this.message = e.localizedMessage
-                                        })
+                                                }
+                                            )
                                         } finally {
                                             logger.debug(" Task name: {} id: {}", it.name, it.id)
                                             processing.update { it - 1 }
@@ -155,7 +170,8 @@ class Consumer(
                                             }
                                         }
                                     }.flowOn(Dispatchers.Default).collect()
-                        })
+                            }
+                        )
                 } catch (e: CancellationException) {
                     throw e
                 } catch (e: Exception) {
@@ -171,14 +187,15 @@ class Consumer(
         while (coroutineScope.isActive) {
             val andSet = concurrent.getAndUpdate { 0 }
 
-
             if (andSet != 0) {
                 logger.debug("Request {} tasks.", andSet)
                 try {
-                    emit(readyRequest {
+                    emit(
+                        readyRequest {
                             this.consumerId = this@Consumer.consumerId
                             this.numberOfConcurrent = andSet
-                    })
+                        }
+                    )
                 } catch (e: CancellationException) {
                     throw e
                 } catch (e: Exception) {

owl/owl-consumer/src/main/kotlin/dev/usbharu/owl/consumer/Main.kt

@@ -25,5 +25,4 @@ fun main() {
         standaloneConsumer.init()
         standaloneConsumer.start()
     }
-
 }

owl/owl-consumer/src/main/kotlin/dev/usbharu/owl/consumer/StandaloneConsumer.kt

@@ -16,11 +16,11 @@
 
 package dev.usbharu.owl.consumer
 
-import dev.usbharu.owl.AssignmentTaskServiceGrpcKt
-import dev.usbharu.owl.SubscribeTaskServiceGrpcKt
-import dev.usbharu.owl.TaskResultServiceGrpcKt
 import dev.usbharu.owl.common.property.CustomPropertySerializerFactory
 import dev.usbharu.owl.common.property.PropertySerializerFactory
+import dev.usbharu.owl.generated.AssignmentTaskServiceGrpcKt
+import dev.usbharu.owl.generated.SubscribeTaskServiceGrpcKt
+import dev.usbharu.owl.generated.TaskResultServiceGrpcKt
 import io.grpc.ManagedChannelBuilder
 import java.nio.file.Path
 
@@ -90,9 +90,11 @@ class StandaloneConsumer(
      */
     suspend fun start() {
         consumer.start()
-        Runtime.getRuntime().addShutdownHook(Thread {
+        Runtime.getRuntime().addShutdownHook(
+            Thread {
                 consumer.stop()
-        })
+            }
+        )
     }
 
     /**
@@ -102,5 +104,4 @@ class StandaloneConsumer(
     fun stop() {
         consumer.stop()
     }
-
 }

owl/owl-producer/owl-producer-default/build.gradle.kts

@@ -34,7 +34,7 @@ protobuf {
             artifact = libs.protoc.gen.grpc.java.get().toString()
         }
         create("grpckt") {
-            artifact = libs.protoc.gen.grpc.kotlin.get().toString() + "jdk8@jar"
+            artifact = libs.protoc.gen.grpc.kotlin.get().toString() + ":jdk8@jar"
         }
     }
     generateProtoTasks {

owl/owl-producer/owl-producer-default/src/main/kotlin/dev/usbharu/owl/producer/defaultimpl/DefaultOwlProducer.kt

@@ -17,12 +17,12 @@
 package dev.usbharu.owl.producer.defaultimpl
 
 import com.google.protobuf.timestamp
-import dev.usbharu.owl.*
-import dev.usbharu.owl.Uuid.UUID
 import dev.usbharu.owl.common.property.PropertySerializeUtils
 import dev.usbharu.owl.common.task.PublishedTask
 import dev.usbharu.owl.common.task.Task
 import dev.usbharu.owl.common.task.TaskDefinition
+import dev.usbharu.owl.generated.*
+import dev.usbharu.owl.generated.Uuid.UUID
 import dev.usbharu.owl.producer.api.OwlProducer
 import java.time.Instant
 
@@ -36,10 +36,12 @@ class DefaultOwlProducer(private val defaultOwlProducerConfig: DefaultOwlProduce
     override suspend fun start() {
         producerServiceCoroutineStub =
             ProducerServiceGrpcKt.ProducerServiceCoroutineStub(defaultOwlProducerConfig.channel)
-        producerId = producerServiceCoroutineStub.registerProducer(producer {
+        producerId = producerServiceCoroutineStub.registerProducer(
+            producer {
                 this.name = defaultOwlProducerConfig.name
                 this.hostname = defaultOwlProducerConfig.hostname
-        }).id
+            }
+        ).id
 
         defineTaskServiceCoroutineStub =
             DefinitionTaskServiceGrpcKt.DefinitionTaskServiceCoroutineStub(defaultOwlProducerConfig.channel)
@@ -48,9 +50,9 @@ class DefaultOwlProducer(private val defaultOwlProducerConfig: DefaultOwlProduce
             TaskPublishServiceGrpcKt.TaskPublishServiceCoroutineStub(defaultOwlProducerConfig.channel)
     }
 
-
     override suspend fun <T : Task> registerTask(taskDefinition: TaskDefinition<T>) {
-        defineTaskServiceCoroutineStub.register(taskDefinition {
+        defineTaskServiceCoroutineStub.register(
+            taskDefinition {
                 this.producerId = this@DefaultOwlProducer.producerId
                 this.name = taskDefinition.name
                 this.maxRetry = taskDefinition.maxRetry
@@ -58,7 +60,8 @@ class DefaultOwlProducer(private val defaultOwlProducerConfig: DefaultOwlProduce
                 this.retryPolicy = taskDefinition.retryPolicy
                 this.timeoutMilli = taskDefinition.timeoutMilli
                 this.propertyDefinitionHash = taskDefinition.propertyDefinition.hash()
-        })
+            }
+        )
     }
 
     override suspend fun <T : Task> publishTask(task: T): PublishedTask<T> {
@@ -69,7 +72,7 @@ class DefaultOwlProducer(private val defaultOwlProducerConfig: DefaultOwlProduce
         )
         val now = Instant.now()
         val publishTask = taskPublishServiceCoroutineStub.publishTask(
-            dev.usbharu.owl.publishTask {
+            dev.usbharu.owl.generated.publishTask {
                 this.producerId = this@DefaultOwlProducer.producerId
 
                 this.publishedAt = timestamp {

owl/owl-producer/owl-producer-embedded/src/main/kotlin/dev/usbharu/owl/producer/embedded/EmbeddedOwlProducer.kt

@@ -96,7 +96,6 @@ class EmbeddedOwlProducer(
     }
 
     override suspend fun <T : Task> publishTask(task: T): PublishedTask<T> {
-
         val taskDefinition = taskMap.getValue(task::class.java) as TaskDefinition<T>
 
         val publishTask = application.get<TaskPublishService>().publishTask(

owl/owl-producer/owl-producer-embedded/src/main/kotlin/dev/usbharu/owl/producer/embedded/EmbeddedOwlProducerBuilder.kt

@@ -46,7 +46,6 @@ class EmbeddedOwlProducerBuilder : OwlProducerBuilder<EmbeddedOwlProducer, Embed
     override fun apply(owlProducerConfig: EmbeddedOwlProducerConfig) {
         this.config = owlProducerConfig
     }
-
 }
 
 val EMBEDDED by lazy { EmbeddedOwlProducerBuilder() }

settings.gradle.kts

@@ -21,6 +21,7 @@ rootProject.name = "hideout"
 
 includeBuild("hideout-core")
 includeBuild("hideout-mastodon")
+includeBuild("hideout-activitypub")
 
 dependencyResolutionManagement {
     repositories {