Small changes

apps/coordinator/src/main/kotlin/no/iktdev/mediaprocessing/coordinator/tasks/event/CreateConvertWorkTask.kt

@@ -4,6 +4,7 @@ import mu.KotlinLogging
 import no.iktdev.mediaprocessing.coordinator.Coordinator
 import no.iktdev.mediaprocessing.coordinator.TaskCreator
 import no.iktdev.mediaprocessing.shared.common.persistance.PersistentMessage
+import no.iktdev.mediaprocessing.shared.common.persistance.isOfEvent
 import no.iktdev.mediaprocessing.shared.common.persistance.lastOf
 import no.iktdev.mediaprocessing.shared.contract.dto.StartOperationEvents
 import no.iktdev.mediaprocessing.shared.contract.dto.isOnly
@@ -31,11 +32,10 @@ class CreateConvertWorkTask(@Autowired override var coordinator: Coordinator) :
         super.onProcessEventsAccepted(event, events)
 
         log.info { "${event.referenceId} @ ${event.eventId} triggered by ${event.event}" }
-        val startedEvent = events.lastOf(KafkaEvents.EventMediaProcessStarted)
         val startedEventData = events.lastOf(KafkaEvents.EventMediaProcessStarted)?.data?.az<MediaProcessStarted>()
-        if (startedEventData?.operations?.isOnly(StartOperationEvents.CONVERT) == true) {
+        if (event.isOfEvent(KafkaEvents.EventMediaProcessStarted) && startedEventData?.operations?.isOnly(StartOperationEvents.CONVERT) == true) {
             val subtitleFile = File(startedEventData.file)
-            return produceConvertWorkRequest(subtitleFile, null, startedEvent?.eventId)
+            return produceConvertWorkRequest(subtitleFile, null, event.eventId)
         } else {
             val derivedInfoObject = if (event.event in requiredEvents) {
                 DerivedInfoObject.fromExtractWorkCreated(event)

apps/processer/src/main/kotlin/no/iktdev/mediaprocessing/processer/ProcesserApplication.kt

@@ -6,11 +6,8 @@ import no.iktdev.exfl.coroutines.CoroutinesIO
 import no.iktdev.exfl.observable.Observables
 import no.iktdev.mediaprocessing.shared.common.DatabaseEnvConfig
 import no.iktdev.mediaprocessing.shared.common.datasource.MySqlDataSource
-import no.iktdev.mediaprocessing.shared.common.persistance.PersistentDataReader
-import no.iktdev.mediaprocessing.shared.common.persistance.PersistentDataStore
 import no.iktdev.mediaprocessing.shared.common.persistance.PersistentEventManager
 import no.iktdev.mediaprocessing.shared.common.persistance.processerEvents
-import no.iktdev.mediaprocessing.shared.common.socket.SocketImplementation
 import no.iktdev.mediaprocessing.shared.common.toEventsDatabase
 import org.jetbrains.exposed.sql.transactions.TransactionManager
 import org.springframework.boot.autoconfigure.SpringBootApplication

apps/ui/web/src/app/page/ExplorePage.tsx

@@ -201,9 +201,6 @@ export default function ExplorePage() {
 
 
   useEffect(() => {
-    if (cursor)
-
-
     // Kjør din funksjon her når komponenten lastes inn for første gang
     // Sjekk om cursor er null
     if (cursor.path === null && client !== null) {

apps/ui/web/src/app/store.ts

@@ -3,6 +3,7 @@ import composedSlice from './store/composed-slice';
 import explorerSlice from './store/explorer-slice';
 import kafkaItemsFlatSlice from './store/kafka-items-flat-slice';
 import contextMenuSlice from './store/context-menu-slice';
+import persistentEventsSlice from './store/persistent-events-slice';
 
 
 export const store = configureStore({
@@ -10,7 +11,8 @@ export const store = configureStore({
     composed: composedSlice,
     explorer: explorerSlice,
     kafkaComposedFlat: kafkaItemsFlatSlice,
-    contextMenu: contextMenuSlice
+    contextMenu: contextMenuSlice,
+    persistentEvents: persistentEventsSlice
   },
 });
 

apps/ui/web/src/types.d.ts

@@ -57,7 +57,7 @@ enum SimpleEventDataState {
     FAILED,
   }
   
-  interface SimpleEventDataObject {
+interface SimpleEventDataObject {
     id: string;
     name?: string | null;
     path?: string | null;
@@ -71,4 +71,22 @@ enum SimpleEventDataState {
     eventCollected: SimpleEventDataState;
     encodingProgress?: number | null;
     encodingTimeLeft?: number | null;
-  }
+}
+
+interface EventObject {
+    referenceId: string;
+    eventId: string;
+    event: string;
+    data: string;
+    created: string;
+}
+
+interface EventsObjectList {
+    referenceId: string;
+    events: Array<EventObject>;
+}
+
+interface EventsObjectListResponse {
+    lastPull: string;
+    items: Array<EventsObjectList>;
+}

shared/common/src/main/kotlin/no/iktdev/mediaprocessing/shared/common/CoordinatorBase.kt

@@ -3,7 +3,6 @@ package no.iktdev.mediaprocessing.shared.common
 import kotlinx.coroutines.*
 import mu.KotlinLogging
 import no.iktdev.exfl.coroutines.CoroutinesDefault
-import no.iktdev.mediaprocessing.shared.common.persistance.PersistentProcessDataMessage
 import no.iktdev.mediaprocessing.shared.common.tasks.EventBasedMessageListener
 import no.iktdev.mediaprocessing.shared.common.tasks.TaskCreatorImpl
 import no.iktdev.mediaprocessing.shared.kafka.core.CoordinatorProducer

shared/common/src/main/kotlin/no/iktdev/mediaprocessing/shared/common/Utils.kt

@@ -3,7 +3,6 @@ package no.iktdev.mediaprocessing.shared.common
 import kotlinx.coroutines.delay
 import mu.KotlinLogging
 import no.iktdev.mediaprocessing.shared.common.persistance.PersistentMessage
-import no.iktdev.mediaprocessing.shared.common.persistance.PersistentProcessDataMessage
 import no.iktdev.mediaprocessing.shared.kafka.core.KafkaEvents
 import no.iktdev.mediaprocessing.shared.kafka.dto.isSuccess
 import java.io.File

shared/common/src/main/kotlin/no/iktdev/mediaprocessing/shared/common/persistance/PersistentDataStore.kt

@@ -1,132 +0,0 @@
-package no.iktdev.mediaprocessing.shared.common.persistance
-
-import mu.KotlinLogging
-import no.iktdev.mediaprocessing.shared.common.datasource.DataSource
-import no.iktdev.mediaprocessing.shared.common.datasource.executeOrException
-import no.iktdev.mediaprocessing.shared.common.datasource.executeWithStatus
-import no.iktdev.mediaprocessing.shared.common.datasource.withTransaction
-import no.iktdev.mediaprocessing.shared.kafka.core.KafkaEvents
-import no.iktdev.mediaprocessing.shared.kafka.dto.Message
-import org.jetbrains.exposed.exceptions.ExposedSQLException
-import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
-import org.jetbrains.exposed.sql.and
-import org.jetbrains.exposed.sql.deleteWhere
-import org.jetbrains.exposed.sql.insert
-import org.jetbrains.exposed.sql.javatime.CurrentDateTime
-import org.jetbrains.exposed.sql.update
-import java.sql.SQLIntegrityConstraintViolationException
-
-private val log = KotlinLogging.logger {}
-open class PersistentDataStore(var dataSource: DataSource) {
-    fun storeEventDataMessage(event: String, message: Message<*>): Boolean {
-        val exception = executeOrException(dataSource.database) {
-            events.insert {
-                it[events.referenceId] = message.referenceId
-                it[events.eventId] = message.eventId
-                it[events.event] = event
-                it[events.data] = message.dataAsJson()
-            }
-        }
-        return if (exception == null) true else {
-            if (exception.cause is SQLIntegrityConstraintViolationException) {
-                log.info { "Error is of SQLIntegrityConstraintViolationException" }
-                try {
-                    log.info { "Error code is: ${ (exception as ExposedSQLException).errorCode}" }
-                } catch (e: Exception) {
-
-                }
-                //exception.printStackTrace()
-                (exception as ExposedSQLException).errorCode == 1062
-            }
-            else {
-                exception.printStackTrace()
-                false
-            }
-        }
-    }
-
-    fun deleteStoredEventDataMessage(referenceId: String, eventId: String, event: KafkaEvents): Boolean {
-        return executeWithStatus(dataSource.database) {
-            events.deleteWhere {
-                (events.referenceId eq referenceId) and
-                        (events.eventId eq eventId) and
-                        (events.event eq event.event)
-            }
-        }
-    }
-
-    fun storeProcessDataMessage(event: String, message: Message<*>): Boolean {
-        val exception = executeOrException(dataSource.database) {
-            processerEvents.insert {
-                it[processerEvents.referenceId] = message.referenceId
-                it[processerEvents.eventId] = message.eventId
-                it[processerEvents.event] = event
-                it[processerEvents.data] = message.dataAsJson()
-            }
-        }
-        return if (exception == null) true else {
-            if (exception.cause is SQLIntegrityConstraintViolationException) {
-                (exception as ExposedSQLException).errorCode == 1062
-            }
-            else {
-                exception.printStackTrace()
-                false
-            }
-        }
-    }
-
-    fun setProcessEventClaim(referenceId: String, eventId: String, claimedBy: String): Boolean {
-        return withTransaction(dataSource.database) {
-            processerEvents.update({
-                (processerEvents.referenceId eq referenceId) and
-                        (processerEvents.eventId eq eventId) and
-                        (processerEvents.claimed eq false)
-            }) {
-                it[processerEvents.claimedBy] = claimedBy
-                it[lastCheckIn] = CurrentDateTime
-                it[claimed] = true
-            }
-        } == 1
-    }
-
-    fun setProcessEventCompleted(referenceId: String, eventId: String, claimedBy: String): Boolean {
-        return withTransaction(dataSource.database) {
-            processerEvents.update({
-                (processerEvents.referenceId eq referenceId) and
-                        (processerEvents.eventId eq eventId) and
-                        (processerEvents.claimedBy eq claimedBy) and
-                        (processerEvents.claimed eq true)
-            }) {
-                it[processerEvents.consumed] = true
-            }
-        } == 1
-    }
-
-    fun updateCurrentProcessEventClaim(referenceId: String, eventId: String, claimedBy: String): Boolean {
-        return executeWithStatus(dataSource.database) {
-            processerEvents.update({
-                (processerEvents.referenceId eq referenceId) and
-                        (processerEvents.eventId eq eventId) and
-                        (processerEvents.claimed eq false) and
-                        (processerEvents.claimedBy eq claimedBy)
-            }) {
-                it[lastCheckIn] = CurrentDateTime
-            }
-        }
-    }
-
-    fun releaseProcessEventClaim(referenceId: String, eventId: String): Boolean {
-        val exception = executeOrException(dataSource.database) {
-            processerEvents.update({
-                (processerEvents.referenceId eq referenceId) and
-                        (processerEvents.eventId eq eventId)
-            }) {
-                it[claimedBy] = null
-                it[lastCheckIn] = null
-                it[claimed] = false
-            }
-        }
-        return exception == null
-    }
-
-}

shared/kafka/src/main/kotlin/no/iktdev/mediaprocessing/shared/kafka/core/KafkaEvents.kt

@@ -1,41 +1,41 @@
 package no.iktdev.mediaprocessing.shared.kafka.core
 
 enum class KafkaEvents(val event: String) {
-    EventMediaProcessStarted("event:media-process:started"),
+    EventMediaProcessStarted                ("event:media-process:started"),
 
-    EventMediaReadStreamPerformed("event:media-read-stream:performed"),
+    EventMediaReadStreamPerformed           ("event:media-read-stream:performed"),
-    EventMediaParseStreamPerformed("event:media-parse-stream:performed"),
+    EventMediaParseStreamPerformed          ("event:media-parse-stream:performed"),
-    EventMediaReadBaseInfoPerformed("event:media-read-base-info:performed"),
+    EventMediaReadBaseInfoPerformed         ("event:media-read-base-info:performed"),
-    EventMediaMetadataSearchPerformed("event:media-metadata-search:performed"),
+    EventMediaMetadataSearchPerformed       ("event:media-metadata-search:performed"),
-    EventMediaReadOutNameAndType("event:media-read-out-name-and-type:performed"),
+    EventMediaReadOutNameAndType            ("event:media-read-out-name-and-type:performed"),
-    EventMediaReadOutCover("event:media-read-out-cover:performed"),
+    EventMediaReadOutCover                  ("event:media-read-out-cover:performed"),
 
-    EventMediaParameterEncodeCreated("event:media-encode-parameter:created"),
+    EventMediaParameterEncodeCreated        ("event:media-encode-parameter:created"),
-    EventMediaParameterExtractCreated("event:media-extract-parameter:created"),
+    EventMediaParameterExtractCreated       ("event:media-extract-parameter:created"),
-    EventMediaParameterConvertCreated("event:media-convert-parameter:created"),
+    EventMediaParameterConvertCreated       ("event:media-convert-parameter:created"),
-    EventMediaParameterDownloadCoverCreated("event:media-download-cover-parameter:created"),
+    EventMediaParameterDownloadCoverCreated ("event:media-download-cover-parameter:created"),
 
-    EventMediaWorkProceedPermitted("event:media-work-proceed:permitted"),
+    EventMediaWorkProceedPermitted          ("event:media-work-proceed:permitted"),
 
     EventNotificationOfWorkItemRemoval("event:notification-work-item-removal"),
 
-    EventWorkEncodeCreated("event:work-encode:created"),
+    EventWorkEncodeCreated                  ("event:work-encode:created"),
-    EventWorkExtractCreated("event:work-extract:created"),
+    EventWorkExtractCreated                 ("event:work-extract:created"),
-    EventWorkConvertCreated("event:work-convert:created"),
+    EventWorkConvertCreated                 ("event:work-convert:created"),
 
-    EventWorkEncodePerformed("event:work-encode:performed"),
+    EventWorkEncodePerformed                ("event:work-encode:performed"),
-    EventWorkExtractPerformed("event:work-extract:performed"),
+    EventWorkExtractPerformed               ("event:work-extract:performed"),
-    EventWorkConvertPerformed("event:work-convert:performed"),
+    EventWorkConvertPerformed               ("event:work-convert:performed"),
-    EventWorkDownloadCoverPerformed("event:work-download-cover:performed"),
+    EventWorkDownloadCoverPerformed         ("event:work-download-cover:performed"),
 
 
-    EVENT_STORE_VIDEO_PERFORMED("event:store-video:performed"),
+    EVENT_STORE_VIDEO_PERFORMED             ("event:store-video:performed"),
-    EVENT_STORE_SUBTITLE_PERFORMED("event:store-subtitle:performed"),
+    EVENT_STORE_SUBTITLE_PERFORMED          ("event:store-subtitle:performed"),
-    EVENT_STORE_COVER_PERFORMED("event:store-cover:performed"),
+    EVENT_STORE_COVER_PERFORMED             ("event:store-cover:performed"),
-    EVENT_STORE_METADATA_PERFORMED("event:store-metadata:performed"),
+    EVENT_STORE_METADATA_PERFORMED          ("event:store-metadata:performed"),
 
-    EventMediaProcessCompleted("event:media-process:completed"),
+    EventMediaProcessCompleted              ("event:media-process:completed"),
-    EventCollectAndStore("event::save"),
+    EventCollectAndStore                    ("event::save"),
 
     ;