Read workload (#69)

src/components/Elements/RegionCard/index.tsx

@@ -157,10 +157,6 @@ const RegionCardInner = ({
     setName('');
   };
 
-  const getTaskName = (taskId: number) => {
-    return tasks.find(({ id }) => id === taskId)?.name || '';
-  };
-
   const locationToLabel = (location: RegionLocation): string => {
     if (location === RegionLocation.REGIONX_CHAIN) {
       return 'RegionX Chain';
@@ -171,6 +167,17 @@ const RegionCardInner = ({
     }
   };
 
+  const getTask = (taskId: number | null): string => {
+    const getTaskName = (taskId: number) => {
+      return tasks.find(({ id }) => id === taskId)?.name || '';
+    };
+
+    if (taskId !== null) {
+      return getTaskName(taskId) ? getTaskName(taskId) : `Parachain: ${taskId}`;
+    }
+    return 'Unassigned';
+  };
+
   return (
     <>
       <div className={styles.regionInfo}>
@@ -253,7 +260,7 @@ const RegionCardInner = ({
       <Box sx={{ color: theme.palette.grey[200] }}>
         {taskId !== null ? (
           <Typography variant='subtitle2'>
-            {`Task: ${taskId ? getTaskName(taskId) : 'Unassigned'}`}
+            {`Task: ${getTask(taskId)}`}
           </Typography>
         ) : (
           <></>

src/contexts/regions/index.tsx

@@ -1,5 +1,5 @@
 import { useInkathon } from '@scio-labs/use-inkathon';
-import { Region, RegionId } from 'coretime-utils';
+import { CoreIndex, CoreMask, Region, RegionId } from 'coretime-utils';
 import React, {
   createContext,
   useCallback,
@@ -48,55 +48,75 @@ const RegionDataProvider = ({ children }: Props) => {
   } = useCoretimeApi();
   const { api, activeAccount } = useInkathon();
 
-  const { fetchTasks } = useTasks();
+  const { fetchWorkplan, fetchRegionWorkload } = useTasks();
 
   const context = useCommon();
 
   const [regions, setRegions] = useState<Array<RegionMetadata>>([]);
   const [loading, setLoading] = useState(false);
 
+  const _getTaskFromWorkloadId = useCallback(
+    async (core: CoreIndex, mask: CoreMask): Promise<number | null> => {
+      const task = await fetchRegionWorkload(core, mask);
+      return task;
+    },
+    [fetchRegionWorkload]
+  );
+
   const fetchRegions = useCallback(async (): Promise<void> => {
     if (!activeAccount) {
       setRegions([]);
       return;
     }
     setLoading(true);
 
-    const tasks = await fetchTasks();
+    const tasks = await fetchWorkplan();
 
     const brokerRegions = await NativeRegions.fetchRegions(coretimeApi);
 
     const _regions: Array<RegionMetadata> = [];
 
     for await (const region of [...brokerRegions]) {
-      const rawId = region.getEncodedRegionId(api);
+      // Only user owned non-expired regions.
+      if (
+        region.getOwner() !== activeAccount.address ||
+        region.consumed(context) > 1
+      )
+        continue;
+
+      const rawId = region.getEncodedRegionId(api).toString();
       const location = RegionLocation.CORETIME_CHAIN;
 
       const name =
         localStorage.getItem(`region-${rawId}`) ??
         `Region #${_regions.length + 1}`;
 
+      const task = tasks[rawId.toString()]
+        ? tasks[rawId.toString()]
+        : await _getTaskFromWorkloadId(region.getCore(), region.getMask());
+
       _regions.push(
         RegionMetadata.construct(
           context,
           region.getEncodedRegionId(api),
           region,
           name,
           location,
-          tasks[rawId.toString()]
+          task
         )
       );
     }
 
-    setRegions(
-      _regions.filter(
-        // Only user owned non-expired regions.
-        ({ region, consumed }) =>
-          region.getOwner() === activeAccount.address && consumed < 1
-      )
-    );
+    setRegions(_regions);
     setLoading(false);
-  }, [activeAccount, context, coretimeApi, api, fetchTasks]);
+  }, [
+    activeAccount,
+    context,
+    coretimeApi,
+    api,
+    fetchWorkplan,
+    _getTaskFromWorkloadId,
+  ]);
 
   useEffect(() => {
     fetchRegions();

src/contexts/tasks/index.tsx

@@ -1,5 +1,5 @@
 import { useInkathon } from '@scio-labs/use-inkathon';
-import { CoreMask, Region } from 'coretime-utils';
+import { CoreIndex, CoreMask, Region } from 'coretime-utils';
 import React, { createContext, useContext, useEffect, useState } from 'react';
 
 import { parseHNString } from '@/utils/functions';
@@ -9,20 +9,28 @@ import { ScheduleItem, TaskMetadata } from '@/models';
 import { useCoretimeApi } from '../apis';
 import { ApiState } from '../apis/types';
 
-type Tasks = Record<string, number | null>;
+type Task = number | null;
+type Tasks = Record<string, Task>;
 
 interface TasksData {
   tasks: Array<TaskMetadata>;
-  fetchTasks: () => Promise<Tasks>;
+  fetchWorkplan: () => Promise<Tasks>;
+  fetchRegionWorkload: (_core: CoreIndex, _mask: CoreMask) => Promise<Task>;
   loadTasksFromLocalStorage: () => void;
   addTask: (_task: TaskMetadata) => void;
 }
 
 const defaultTasksData: TasksData = {
   tasks: [],
-  fetchTasks: async (): Promise<Tasks> => {
+  fetchWorkplan: async (): Promise<Tasks> => {
     return {};
   },
+  fetchRegionWorkload: async (
+    _core: CoreIndex,
+    _mask: CoreMask
+  ): Promise<Task> => {
+    return null;
+  },
   loadTasksFromLocalStorage: () => {
     /** */
   },
@@ -47,7 +55,8 @@ const TaskDataProvider = ({ children }: Props) => {
 
   const STORAGE_ITEM_KEY = 'tasks';
 
-  const fetchTasks = async (): Promise<Tasks> => {
+  // The tasks which will run on Polkadot cores in the future.
+  const fetchWorkplan = async (): Promise<Tasks> => {
     if (!coretimeApi || coretimeApiState !== ApiState.READY) return {};
     const workplan = await coretimeApi.query.broker.workplan.entries();
     const tasks: Record<string, number | null> = {};
@@ -76,9 +85,33 @@ const TaskDataProvider = ({ children }: Props) => {
           : null;
       });
     }
+
     return tasks;
   };
 
+  // The tasks currently running on a Polkadot core.
+  const fetchRegionWorkload = async (
+    core: CoreIndex,
+    regionMask: CoreMask
+  ): Promise<Task> => {
+    if (!coretimeApi || coretimeApiState !== ApiState.READY) return null;
+    const workload = (
+      (
+        await coretimeApi.query.broker.workload(core)
+      ).toHuman() as ScheduleItem[]
+    )[0];
+    if (workload.assignment && workload.assignment.Task) {
+      const {
+        assignment: { Task: taskId },
+        mask,
+      } = workload;
+
+      // Make the workload is for the specific region.
+      return mask == regionMask.toRawHex() ? parseHNString(taskId) : null;
+    }
+    return 0;
+  };
+
   const loadTasksFromLocalStorage = () => {
     const strTasks = localStorage.getItem(STORAGE_ITEM_KEY);
     if (!strTasks) {
@@ -105,7 +138,13 @@ const TaskDataProvider = ({ children }: Props) => {
 
   return (
     <TaskDataContext.Provider
-      value={{ tasks, fetchTasks, loadTasksFromLocalStorage, addTask }}
+      value={{
+        tasks,
+        fetchWorkplan,
+        fetchRegionWorkload,
+        loadTasksFromLocalStorage,
+        addTask,
+      }}
     >
       {children}
     </TaskDataContext.Provider>

src/pages/_app.tsx

@@ -62,15 +62,15 @@ export default function MyApp(props: MyAppProps) {
                 apiOptions={{ types: { Id } }}
               >
                 <ContextDataProvider>
-                  <RegionDataProvider>
-                    <MarketProvider>
-                      <SaleInfoProvider>
-                        <TaskDataProvider>
+                  <TaskDataProvider>
+                    <RegionDataProvider>
+                      <MarketProvider>
+                        <SaleInfoProvider>
                           {getLayout(<Component {...pageProps} />)}
-                        </TaskDataProvider>
-                      </SaleInfoProvider>
-                    </MarketProvider>
-                  </RegionDataProvider>
+                        </SaleInfoProvider>
+                      </MarketProvider>
+                    </RegionDataProvider>
+                  </TaskDataProvider>
                 </ContextDataProvider>
               </UseInkathonProvider>
             </RelayApiContextProvider>