chore: update boot progress schema

Author: asuzuki-jumptrading

src/api/entities.ts

@@ -239,134 +239,66 @@ export const BootPhaseEnum = bootPhaseSchema.enum;
 
 export const bootProgressSchema = z.object({
   phase: bootPhaseSchema,
-  total_elapsed: z.number(),
-
-  // joining_gossip
-  joining_gossip_elapsed: z.number().nullable(),
-
-  // loading_full_snapshot
-  loading_full_snapshot_reset_cnt: z.number().nullable().optional(),
+  joining_gossip_elapsed_seconds: z.number().nullable().optional(),
+  loading_full_snapshot_elapsed_seconds: z.number().nullable().optional(),
+  loading_full_snapshot_reset_count: z.number().nullable().optional(),
   loading_full_snapshot_slot: z.number().nullable().optional(),
-  loading_full_snapshot_peer: z.string().nullable().optional(),
-  loading_full_snapshot_peer_identity: z.string().nullable().optional(),
-  loading_full_snapshot_total_bytes: z.coerce.number().nullable().optional(),
-  loading_full_snapshot_elapsed: z.number().nullable().optional(),
-  loading_full_snapshot_read_bytes: z.coerce.number().nullable().optional(),
-  loading_full_snapshot_read_throughput: z.number().nullable().optional(),
-  loading_full_snapshot_current_bytes: z.coerce.number().nullable().optional(),
-  loading_full_snapshot_read_remaining: z.number().nullable().optional(),
-  loading_full_snapshot_read_elapsed: z.number().nullable().optional(),
-  loading_full_snapshot_read_path: z.string().nullable().optional(),
-  loading_full_snapshot_decompress_bytes: z.number().nullable().optional(),
-  loading_full_snapshot_decompress_elapsed: z.number().nullable().optional(),
-  loading_full_snapshot_decompress_throughput: z.number().nullable().optional(),
-  loading_full_snapshot_decompress_compressed_bytes: z.coerce
-    .number()
-    .nullable()
-    .optional(),
-  loading_full_snapshot_decompress_decompressed_bytes: z.coerce
-    .number()
-    .nullable()
-    .optional(),
-  loading_full_snapshot_decompress_remaining: z.number().nullable().optional(),
-  loading_full_snapshot_insert_bytes: z.coerce.number().nullable().optional(),
-  loading_full_snapshot_insert_throughput: z.number().nullable().optional(),
-  loading_full_snapshot_insert_remaining: z.number().nullable().optional(),
-  loading_full_snapshot_insert_path: z.string().nullable().optional(),
-  loading_full_snapshot_insert_elapsed: z.number().nullable().optional(),
-  loading_full_snapshot_insert_accounts_throughput: z
-    .number()
-    .nullable()
-    .optional(),
-  loading_full_snapshot_insert_accounts_current: z
-    .number()
-    .nullable()
-    .optional(),
-
-  // loading_incremental_snapshot
-  loading_incremental_snapshot_reset_cnt: z.number().nullable().optional(),
-  loading_incremental_snapshot_peer_identity: z.string().nullable().optional(),
-  loading_incremental_snapshot_slot: z.number().nullable().optional(),
-  loading_incremental_snapshot_peer: z.string().nullable().optional(),
-  loading_incremental_snapshot_total_bytes: z.coerce
+  loading_full_snapshot_total_bytes_compressed: z.coerce
     .number()
     .nullable()
     .optional(),
-  loading_incremental_snapshot_elapsed: z.number().nullable().optional(),
-  loading_incremental_snapshot_read_bytes: z.coerce
+  loading_full_snapshot_read_bytes_compressed: z.coerce
     .number()
     .nullable()
     .optional(),
-  loading_incremental_snapshot_read_elapsed: z.number().nullable().optional(),
-  loading_incremental_snapshot_read_throughput: z
+  loading_full_snapshot_read_path: z.string().nullable().optional(),
+  loading_full_snapshot_decompress_bytes_decompressed: z.coerce
     .number()
     .nullable()
     .optional(),
-  loading_incremental_snapshot_read_remaining: z.number().nullable().optional(),
-  loading_incremental_snapshot_read_path: z.string().nullable().optional(),
-  loading_incremental_snapshot_current_bytes: z.coerce
+  loading_full_snapshot_decompress_bytes_compressed: z.coerce
     .number()
     .nullable()
     .optional(),
-  loading_incremental_snapshot_decompress_bytes: z.coerce
+  loading_full_snapshot_insert_bytes_decompressed: z.coerce
     .number()
     .nullable()
     .optional(),
+  loading_full_snapshot_insert_accounts: z.number().nullable().optional(),
 
-  loading_incremental_snapshot_decompress_elapsed: z
+  loading_incremental_snapshot_elapsed_seconds: z
     .number()
     .nullable()
     .optional(),
-  loading_incremental_snapshot_decompress_throughput: z
-    .number()
-    .nullable()
-    .optional(),
-  loading_incremental_snapshot_decompress_compressed_bytes: z.coerce
-    .number()
-    .nullable()
-    .optional(),
-  loading_incremental_snapshot_decompress_decompressed_bytes: z.coerce
-    .number()
-    .nullable()
-    .optional(),
-  loading_incremental_snapshot_decompress_remaining: z
+  loading_incremental_snapshot_reset_count: z.number().nullable().optional(),
+  loading_incremental_snapshot_slot: z.number().nullable().optional(),
+  loading_incremental_snapshot_total_bytes_compressed: z.coerce
     .number()
     .nullable()
     .optional(),
-  loading_incremental_snapshot_insert_bytes: z.coerce
+  loading_incremental_snapshot_read_bytes_compressed: z.coerce
     .number()
     .nullable()
     .optional(),
-  loading_incremental_snapshot_insert_elapsed: z.number().nullable().optional(),
-  loading_incremental_snapshot_insert_throughput: z
+  loading_incremental_snapshot_read_path: z.string().nullable().optional(),
+  loading_incremental_snapshot_decompress_bytes_decompressed: z.coerce
     .number()
     .nullable()
     .optional(),
-  loading_incremental_snapshot_insert_remaining: z
+  loading_incremental_snapshot_decompress_bytes_compressed: z.coerce
     .number()
     .nullable()
     .optional(),
-  loading_incremental_snapshot_insert_path: z.string().nullable().optional(),
-  loading_incremental_snapshot_insert_accounts_throughput: z
+  loading_incremental_snapshot_insert_bytes_decompressed: z.coerce
     .number()
     .nullable()
     .optional(),
-  loading_incremental_snapshot_insert_accounts_current: z
+  loading_incremental_snapshot_insert_accounts: z
     .number()
     .nullable()
     .optional(),
 
-  // catching_up
-  catching_up_elapsed: z.number().nullable().optional(),
-  catching_up_min_turbine_slot: z.number().nullable().optional(),
-  catching_up_max_turbine_slot: z.number().nullable().optional(),
-  catching_up_min_repair_slot: z.number().nullable().optional(),
-  catching_up_max_repair_slot: z.number().nullable().optional(),
-  catching_up_max_replay_slot: z.number().nullable().optional(),
-  catching_up_first_turbine_slot: z.number().nullable().optional(),
-  catching_up_latest_turbine_slot: z.number().nullable().optional(),
-  catching_up_latest_repair_slot: z.number().nullable().optional(),
-  catching_up_latest_replay_slot: z.number().nullable().optional(),
+  catching_up_elapsed_seconds: z.number().nullable().optional(),
 });
 
 export const slotTransactionsSchema = z.object({

src/features/StartupProgress/Firedancer/Body.tsx

@@ -1,9 +1,9 @@
 import { useAtomValue, useSetAtom } from "jotai";
-import { bootProgressAtom } from "../../../api/atoms";
 import styles from "./body.module.css";
 import { useEffect } from "react";
 import {
   bootProgressPhaseAtom,
+  bootProgressTotalElapsedAtom,
   isStartupProgressExpandedAtom,
   showStartupProgressAtom,
 } from "../atoms";
@@ -94,7 +94,7 @@ function BootProgressContent({ phase }: BootProgressContentProps) {
 }
 
 function TotalDuration() {
-  const totalElapsed = useAtomValue(bootProgressAtom)?.total_elapsed;
+  const totalElapsed = useAtomValue(bootProgressTotalElapsedAtom);
   const duration = totalElapsed == null ? "--" : formatDuration(totalElapsed);
   return <Text>{duration}</Text>;
 }

src/features/StartupProgress/Firedancer/SnapshotLoadingCard.tsx

@@ -9,17 +9,17 @@ const MAX_THROUGHPUT = 300000000;
 
 interface SnapshotLoadingCardProps {
   title: string;
-  estimatedRemaining?: number | null;
-  throughput?: number | null;
   completed?: number | null;
   total?: number | null;
 }
 export function SnapshotLoadingCard({
   title,
-  throughput,
   completed,
   total,
 }: SnapshotLoadingCardProps) {
+  // TODO: calculate throughput
+  const throughput = 0;
+
   const throughputObj = throughput == null ? undefined : byteSize(throughput);
   const completedObj = completed == null ? undefined : byteSize(completed);
   const totalObj = total == null ? undefined : byteSize(total);

src/features/StartupProgress/Firedancer/SnapshotProgress.tsx

@@ -10,70 +10,42 @@ const rowGap = "5";
 
 function getSnapshotValues(bootProgress: BootProgress) {
   const {
-    loading_full_snapshot_total_bytes,
-    loading_full_snapshot_read_remaining,
-    loading_full_snapshot_read_bytes,
-    loading_full_snapshot_read_throughput,
+    loading_full_snapshot_total_bytes_compressed,
+    loading_full_snapshot_read_bytes_compressed,
+    loading_full_snapshot_decompress_bytes_compressed,
+    loading_full_snapshot_decompress_bytes_decompressed,
+    loading_full_snapshot_insert_bytes_decompressed,
 
-    loading_full_snapshot_decompress_remaining,
-    loading_full_snapshot_decompress_throughput,
-    loading_full_snapshot_decompress_compressed_bytes,
-    loading_full_snapshot_decompress_decompressed_bytes,
-
-    loading_full_snapshot_insert_remaining,
-    loading_full_snapshot_insert_bytes,
-    loading_full_snapshot_insert_throughput,
-
-    loading_incremental_snapshot_total_bytes,
-    loading_incremental_snapshot_read_remaining,
-    loading_incremental_snapshot_read_bytes,
-    loading_incremental_snapshot_read_throughput,
-
-    loading_incremental_snapshot_decompress_remaining,
-    loading_incremental_snapshot_decompress_throughput,
-    loading_incremental_snapshot_decompress_compressed_bytes,
-    loading_incremental_snapshot_decompress_decompressed_bytes,
-
-    loading_incremental_snapshot_insert_remaining,
-    loading_incremental_snapshot_insert_bytes,
-    loading_incremental_snapshot_insert_throughput,
+    loading_incremental_snapshot_total_bytes_compressed,
+    loading_incremental_snapshot_read_bytes_compressed,
+    loading_incremental_snapshot_decompress_bytes_compressed,
+    loading_incremental_snapshot_decompress_bytes_decompressed,
+    loading_incremental_snapshot_insert_bytes_decompressed,
   } = bootProgress;
 
   if (
     bootProgress.phase === BootPhaseEnum.loading_full_snapshot ||
-    !loading_incremental_snapshot_total_bytes
+    !loading_incremental_snapshot_total_bytes_compressed
   ) {
     return {
-      total_bytes: loading_full_snapshot_total_bytes,
-      read_remaining: loading_full_snapshot_read_remaining,
-      read_bytes: loading_full_snapshot_read_bytes,
-      read_throughput: loading_full_snapshot_read_throughput,
-      decompress_remaining: loading_full_snapshot_decompress_remaining,
-      decompress_throughput: loading_full_snapshot_decompress_throughput,
-      decompress_compressed_bytes:
-        loading_full_snapshot_decompress_compressed_bytes,
-      decompress_decompressed_bytes:
-        loading_full_snapshot_decompress_decompressed_bytes,
-      insert_remaining: loading_full_snapshot_insert_remaining,
-      insert_bytes: loading_full_snapshot_insert_bytes,
-      insert_throughput: loading_full_snapshot_insert_throughput,
+      totalBytes: loading_full_snapshot_total_bytes_compressed,
+      readBytes: loading_full_snapshot_read_bytes_compressed,
+      decompressCompressedBytes:
+        loading_full_snapshot_decompress_bytes_compressed,
+      decompressDecompressedBytes:
+        loading_full_snapshot_decompress_bytes_decompressed,
+      insertBytes: loading_full_snapshot_insert_bytes_decompressed,
     };
   }
 
   return {
-    total_bytes: loading_incremental_snapshot_total_bytes,
-    read_remaining: loading_incremental_snapshot_read_remaining,
-    read_bytes: loading_incremental_snapshot_read_bytes,
-    read_throughput: loading_incremental_snapshot_read_throughput,
-    decompress_remaining: loading_incremental_snapshot_decompress_remaining,
-    decompress_throughput: loading_incremental_snapshot_decompress_throughput,
-    decompress_compressed_bytes:
-      loading_incremental_snapshot_decompress_compressed_bytes,
-    decompress_decompressed_bytes:
-      loading_incremental_snapshot_decompress_decompressed_bytes,
-    insert_remaining: loading_incremental_snapshot_insert_remaining,
-    insert_bytes: loading_incremental_snapshot_insert_bytes,
-    insert_throughput: loading_incremental_snapshot_insert_throughput,
+    totalBytes: loading_incremental_snapshot_total_bytes_compressed,
+    readBytes: loading_incremental_snapshot_read_bytes_compressed,
+    decompressCompressedBytes:
+      loading_incremental_snapshot_decompress_bytes_compressed,
+    decompressDecompressedBytes:
+      loading_incremental_snapshot_decompress_bytes_decompressed,
+    insertBytes: loading_incremental_snapshot_insert_bytes_decompressed,
   };
 }
 
@@ -82,73 +54,60 @@ export function SnapshotProgress() {
   if (!bootProgress) return;
 
   const {
-    total_bytes,
-    read_remaining,
-    read_bytes,
-    read_throughput,
-    decompress_remaining,
-    decompress_throughput,
-    decompress_compressed_bytes,
-    decompress_decompressed_bytes,
-    insert_remaining,
-    insert_bytes,
-    insert_throughput,
+    totalBytes,
+    readBytes,
+    decompressCompressedBytes,
+    decompressDecompressedBytes,
+    insertBytes,
   } = getSnapshotValues(bootProgress);
 
   const insertCompletedBytes =
-    insert_bytes && decompress_compressed_bytes && decompress_decompressed_bytes
-      ? insert_bytes *
-        (decompress_compressed_bytes / decompress_decompressed_bytes)
+    insertBytes && decompressCompressedBytes && decompressDecompressedBytes
+      ? insertBytes * (decompressCompressedBytes / decompressDecompressedBytes)
       : 0;
 
   return (
     <Flex direction="column" gap="40px">
       <Flex gap={rowGap}>
         <SnapshotLoadingCard
           title="Reading"
-          estimatedRemaining={read_remaining}
-          throughput={read_throughput}
-          completed={read_bytes}
-          total={total_bytes}
+          completed={readBytes}
+          total={totalBytes}
         />
         <SnapshotSparklineCard
           title="CPU Utilization"
           tileType="snaprd"
-          isComplete={!!read_remaining && read_remaining === total_bytes}
+          isComplete={!!readBytes && readBytes === totalBytes}
         />
       </Flex>
 
       <Flex gap={rowGap}>
         <SnapshotLoadingCard
           title="Decompressing"
-          estimatedRemaining={decompress_remaining}
-          throughput={decompress_throughput}
-          completed={decompress_compressed_bytes}
-          total={total_bytes}
+          completed={decompressCompressedBytes}
+          total={totalBytes}
         />
         <SnapshotSparklineCard
           title="CPU Utilization"
           tileType="snapdc"
           isComplete={
-            !!decompress_compressed_bytes &&
-            decompress_compressed_bytes === total_bytes
+            !!decompressCompressedBytes &&
+            decompressCompressedBytes === totalBytes
           }
         />
       </Flex>
 
       <Flex gap={rowGap}>
         <SnapshotLoadingCard
           title="Inserting"
-          estimatedRemaining={insert_remaining}
-          throughput={insert_throughput}
           completed={insertCompletedBytes}
-          total={total_bytes}
+          total={totalBytes}
         />
         <SnapshotSparklineCard
           title="CPU Utilization"
           tileType="snapin"
           isComplete={
-            !!insertCompletedBytes && insertCompletedBytes === total_bytes
+            !!insertCompletedBytes && insertCompletedBytes === totalBytes
           }
         />
       </Flex>