Accessing multiple services from same machine template and general architecture question

[Wastl77]

Hi,

my name is Basti and i'm building a software as fallback for an emergency dispatch program. It runs locally in a LAN and consists of one "server" PC and a limited number of clients (max. 12 clients). I need to keep track of the state of many emergency units, all with the same behaviour, hence the same machine definition as shown here:

import { actions, createMachine } from 'xstate';
import { missionServices } from '../index.mjs';

export const resourceMachine =
 
  createMachine({
    predictableActionArguments: true,
    id: 'Resource',
    context: {
      actualMission: 1,
    },
    initial: 'availableStates.D2',

    states: {
      availableStates: {
        states: {
          D2: {
            on: {
              setStatus1: {
                target: 'D1',
                actions: (context, event) => {
                  missionServices[context.actualMission].send(
                    'resourceAlarmed'
                  );
                },
              },
              arrangeResource: '#Resource.reservedStates.Qt2',
              setStatusÜ2: '#Resource.üPool.Ü2',
            },
          },

          D1: {
            on: {
              arrangeResource: '#Resource.reservedStates.Qt1',
              setStatusÜ1: '#Resource.üPool.Ü1',
              setStatus2: 'D2',
            },
          },
        },

        initial: 'D2',
      },

      reservedStates: {
        states: {
          Qt2: {
            on: {
              setStatus3: 'R3',
            },
          },

          Qt1: {
            on: {
              setStatus3: 'R3',
            },
          },

          R3: {
            on: {
              setStatu4: 'R4',
              setStatusEA: 'EA',
            },
          },

          R4: {
            on: {
              setStatus1: '#Resource.availableStates.D1',
              setStatus7: 'R7',
            },
          },

          EA: {
            on: {
              setStatus1: '#Resource.availableStates.D1',
            },
          },

          R7: {
            on: {
              setStatus8: 'R8',
            },
          },

          R8: {
            on: {
              setStatus1: '#Resource.availableStates.D1',
            },
          },
        },

        initial: 'Qt2',
      },

      üPool: {
        states: {
          Ü1: {
            on: {
              setStatus1: '#Resource.availableStates.D1',
            },
          },
          Ü2: {
            on: {
              setStatus2: '#Resource.availableStates.D2',
            },
          },
        },

        initial: 'Ü2',
      },
    },

    initial: 'availableStates',
  });

I'm starting the service for each resource (unit) like so:

import { interpret } from 'xstate';
import { resourceMachine } from './resourceMachine.mjs';
import resources from '../../data/resources.json' assert { type: 'json' };

const resourceServices = {};

resources.forEach((resource) => {
  const resourceService = interpret(
    resourceMachine
  ).start();
  resourceServices[resource.callsign] = resourceService;
});

export default resourceServices;

State transitions are triggered via REST or WebSockets by accessing the unit callsign in the resourceServices object:

resourceServices[callsign].send('setStatus1');

My first question, is this the recommended way for this use case, or more an anti-pattern?

Following this, there is also a machine for the missions, or scene. The running services are also stored in a object. (Machine is WiP):

import { createMachine } from 'xstate';

export const createMissionMachine = (missionNumber, street) =>
  createMachine({
    predictableActionArguments: true,
    id: 'Mission',

    context: {
      missionNumber,
      street,
    },

    states: {
      created: {
        on: {
          resourceAlarmed: 'alarmed',
        },
      },

      alarmed: {},
    },

    initial: 'created',
  });

The next question is about the "connectivity" between the resourceServices and the missionServices, currently i've solved it like this:

context: {
      actualMission: 1,
    },
    initial: 'availableStates.D2',

    states: {
      availableStates: {
        states: {
          D2: {
            on: {
              setStatus1: {
                target: 'D1',
                actions: (context, event) => {
                  missionServices[context.actualMission].send(
                    'resourceAlarmed'
                  );
                },
              },

Also here, are there better ways to do this?

Thank you very much for your comments and thoughts!

[alexamy]

You can spawn any number of missionMachine as an actors in any moment when running resourceMachine, and save references in a context. This will help to control full lifecycle of a mission machine in scope of xstate. Did you try this?

[Wastl77]

Hello Alexander,

thanks for your suggestion, i'm currently in Hospital and try out as soon as possible. I will give you feedback then.

Thanks!