temp impl

Author: BFergerson

build.gradle.kts

@@ -52,6 +52,7 @@ dependencies {
     implementation("eu.geekplace.javapinning:java-pinning-core:1.2.0")
 
     implementation("com.fasterxml.jackson.module:jackson-module-kotlin:$jacksonVersion")
+    implementation("org.jetbrains.kotlinx:kotlinx-datetime:0.3.1")
 
     testImplementation("org.junit.jupiter:junit-jupiter-engine:$jupiterVersion")
 }

src/main/kotlin/spp/cli/PlatformCLI.kt

@@ -3,12 +3,18 @@ package spp.cli
 import com.apollographql.apollo.ApolloClient
 import com.auth0.jwt.JWT
 import com.auth0.jwt.algorithms.Algorithm
+import com.fasterxml.jackson.databind.module.SimpleModule
 import com.github.ajalt.clikt.core.CliktCommand
 import com.github.ajalt.clikt.parameters.options.default
 import com.github.ajalt.clikt.parameters.options.flag
 import com.github.ajalt.clikt.parameters.options.option
 import com.github.ajalt.clikt.parameters.types.file
 import eu.geekplace.javapinning.JavaPinning
+import io.vertx.core.json.jackson.DatabindCodec
+import kotlinx.datetime.Clock
+import kotlinx.datetime.DateTimeUnit
+import kotlinx.datetime.Instant
+import kotlinx.datetime.plus
 import okhttp3.OkHttpClient
 import okhttp3.Request
 import org.bouncycastle.cert.X509CertificateHolder
@@ -18,14 +24,13 @@ import org.bouncycastle.openssl.PEMKeyPair
 import org.bouncycastle.openssl.PEMParser
 import org.bouncycastle.openssl.jcajce.JcaPEMKeyConverter
 import org.bouncycastle.util.encoders.Hex
+import spp.protocol.util.KSerializers
 import java.io.File
 import java.io.StringReader
 import java.security.SecureRandom
 import java.security.cert.X509Certificate
 import java.security.interfaces.RSAPrivateKey
 import java.security.interfaces.RSAPublicKey
-import java.time.Instant
-import java.time.temporal.ChronoUnit
 import javax.net.ssl.SSLContext
 import javax.net.ssl.TrustManager
 import javax.net.ssl.X509TrustManager
@@ -56,7 +61,12 @@ object PlatformCLI : CliktCommand(name = "spp-cli", allowMultipleSubcommands = t
         }
     }
 
-    override fun run() = Unit
+    override fun run() {
+        val module = SimpleModule()
+        module.addSerializer(Instant::class.java, KSerializers.KotlinInstantSerializer())
+        module.addDeserializer(Instant::class.java, KSerializers.KotlinInstantDeserializer())
+        DatabindCodec.mapper().registerModule(module)
+    }
 
     private fun connectToPlatform(): ApolloClient {
         val serverUrl = if (platformHost.startsWith("http")) {
@@ -99,8 +109,8 @@ object PlatformCLI : CliktCommand(name = "spp-cli", allowMultipleSubcommands = t
             jwtToken = JWT.create()
                 .withIssuer("cli")
                 .withClaim("developer_id", "system") //users with key are automatically considered system
-                .withClaim("created_at", Instant.now().toEpochMilli())
-                .withClaim("expires_at", Instant.now().plus(365, ChronoUnit.DAYS).toEpochMilli())
+                .withClaim("created_at", Clock.System.now().toEpochMilliseconds())
+                .withClaim("expires_at", Clock.System.now().plus(8760, DateTimeUnit.HOUR).toEpochMilliseconds())
                 .sign(algorithm)
         } else {
             val tokenUri = "$serverUrl/api/new-token?access_token=$accessToken"

src/main/kotlin/spp/cli/commands/instrument/SubscribeEvents.kt

@@ -21,6 +21,11 @@ import spp.cli.PlatformCLI
 import spp.protocol.SourceMarkerServices
 import spp.protocol.extend.TCPServiceFrameParser
 import spp.protocol.instrument.LiveInstrumentEvent
+import spp.protocol.instrument.LiveInstrumentEventType
+import spp.protocol.instrument.breakpoint.event.LiveBreakpointHit
+import spp.protocol.instrument.breakpoint.event.LiveBreakpointRemoved
+import spp.protocol.instrument.log.event.LiveLogHit
+import spp.protocol.instrument.log.event.LiveLogRemoved
 
 class SubscribeEvents : CliktCommand(
     help = "Listens for and outputs live events. Subscribes to all events by default"
@@ -30,22 +35,17 @@ class SubscribeEvents : CliktCommand(
         name = "Instrument IDs",
         help = "Capture events from specific live instruments"
     ).multiple()
+
     val includeBreakpoints by option("--breakpoints", "-b", help = "Include live breakpoint events")
         .flag(default = false)
     val includeLogs by option("--logs", "-l", help = "Include live log events")
         .flag(default = false)
-    val includeMetrics by option("--metrics", "-m", help = "Include live metric events")
+    val includeMeters by option("--meters", "-m", help = "Include live meter events")
         .flag(default = false)
     val includeTraces by option("--traces", "-t", help = "Include live trace events")
         .flag(default = false)
 
     override fun run() {
-        if (!includeBreakpoints && !includeLogs && !includeMetrics && !includeTraces) {
-            //listen for all events
-        } else {
-            //listen for specific events
-        }
-
         var eventCount = 1
         runBlocking {
             val vertx = Vertx.vertx()
@@ -73,12 +73,75 @@ class SubscribeEvents : CliktCommand(
             socket!!.handler(FrameParser(TCPServiceFrameParser(vertx, socket)))
 
             vertx.eventBus().consumer<JsonObject>("local." + SourceMarkerServices.Provide.LIVE_INSTRUMENT_SUBSCRIBER) {
-                val event = Json.decodeValue(it.body().toString(), LiveInstrumentEvent::class.java)
-                println(
-                    "\nEvent (${eventCount++}):\n" +
-                            "\tType: ${event.eventType}\n" +
-                            "\tData: ${event.data}"
-                )
+                val liveEvent = Json.decodeValue(it.body().toString(), LiveInstrumentEvent::class.java)
+
+                //todo: impl filter on platform
+                if (instrumentIds.isNotEmpty()) {
+                    when (liveEvent.eventType) {
+                        LiveInstrumentEventType.LOG_HIT -> {
+                            val logHit = Json.decodeValue(liveEvent.data, LiveLogHit::class.java)
+                            if (logHit.logId !in instrumentIds) {
+                                return@consumer
+                            }
+                        }
+                        LiveInstrumentEventType.BREAKPOINT_HIT -> {
+                            val breakpointHit = Json.decodeValue(liveEvent.data, LiveBreakpointHit::class.java)
+                            if (breakpointHit.breakpointId !in instrumentIds) {
+                                return@consumer
+                            }
+                        }
+                        LiveInstrumentEventType.BREAKPOINT_REMOVED -> {
+                            val breakpointRemoved = Json.decodeValue(liveEvent.data, LiveBreakpointRemoved::class.java)
+                            if (breakpointRemoved.breakpointId !in instrumentIds) {
+                                return@consumer
+                            }
+                        }
+                        LiveInstrumentEventType.LOG_REMOVED -> {
+                            val logRemoved = Json.decodeValue(liveEvent.data, LiveLogRemoved::class.java)
+                            if (logRemoved.logId !in instrumentIds) {
+                                return@consumer
+                            }
+                        }
+                        else -> TODO("Unhandled event type: ${liveEvent.eventType}")
+                    }
+                }
+
+                if (!includeBreakpoints && !includeLogs && !includeMeters && !includeTraces) {
+                    //listen for all events
+                    println(
+                        "\nEvent (${eventCount++}):\n" +
+                                "\tType: ${liveEvent.eventType}\n" +
+                                "\tData: ${liveEvent.data}"
+                    )
+                } else {
+                    //todo: impl filtering on platform
+                    //listen for specific events
+                    if (includeBreakpoints && liveEvent.eventType.name.startsWith("breakpoint", true)) {
+                        println(
+                            "\nEvent (${eventCount++}):\n" +
+                                    "\tType: ${liveEvent.eventType}\n" +
+                                    "\tData: ${liveEvent.data}"
+                        )
+                    } else if (includeLogs && liveEvent.eventType.name.startsWith("log", true)) {
+                        println(
+                            "\nEvent (${eventCount++}):\n" +
+                                    "\tType: ${liveEvent.eventType}\n" +
+                                    "\tData: ${liveEvent.data}"
+                        )
+                    } else if (includeMeters && liveEvent.eventType.name.startsWith("meter", true)) {
+                        println(
+                            "\nEvent (${eventCount++}):\n" +
+                                    "\tType: ${liveEvent.eventType}\n" +
+                                    "\tData: ${liveEvent.data}"
+                        )
+                    } else if (includeTraces && liveEvent.eventType.name.startsWith("trace", true)) {
+                        println(
+                            "\nEvent (${eventCount++}):\n" +
+                                    "\tType: ${liveEvent.eventType}\n" +
+                                    "\tData: ${liveEvent.data}"
+                        )
+                    }
+                }
             }
 
             //register listener