Block Queue¶

interface CommandQueueInfo {

  // Yamcs instance name
  instance: string;

  // Processor name
  processorName: string;

  // Command queue name
  name: string;

  // Current queue state
  state: QueueState;

  // Submitted commands are matches to the first queue that
  // whose filter criteria (if any) match the command's
  // features. Queues are considered in the order specified by
  // this field, going from lowest to highest.
  order: number;

  // This queue only considers commands that are issued
  // by one of the users in this list.
  //
  // If the list is empty, all commands are considered.
  //
  // Note that users/groups are considered at the same time
  // (a match with any of the two is sufficient).
  users: string[];

  // This queue only considers commands that are issued
  // by one of the users who belongs to any of these groups.
  //
  // If the list is empty, all commands are considered.
  //
  // Note that users/groups are considered at the same time
  // (a match with any of the two is sufficient).
  groups: string[];

  // This queue only considers commands that are at least
  // as significant as this level.
  minLevel: SignificanceLevelType;

  // This queue only considers commands whose qualified name
  // matches any of the regular expressions in this list.
  //
  // If the list is empty, all commands are considered.
  tcPatterns: string[];

  // Currently pending (queued) commands
  entries: CommandQueueEntry[];

  // Number of commands that successfully passed through this queue.
  acceptedCommandsCount: number;

  // Number of commands that were rejected by this queue.
  rejectedCommandsCount: number;
}

//One entry (command) in the command queue
interface CommandQueueEntry {
  instance: string;
  processorName: string;
  queueName: string;
  id: string;
  origin: string;
  sequenceNumber: number;
  commandName: string;
  assignments: CommandAssignment[];
  binary: string;  // Base64
  username: string;
  comment: string;
  generationTime: string;  // RFC 3339 timestamp

  // If true, the command has been accepted and is due for release
  // as soon as transmission constraints are satisfied.
  pendingTransmissionConstraints: boolean;
}

interface CommandAssignment {
  name: string;
  value: Value;
  userInput: boolean;
}

// Union type for storing a value
interface Value {
  type: Type;
  floatValue: number;
  doubleValue: number;
  sint32Value: number;
  uint32Value: number;
  binaryValue: string;  // Base64
  stringValue: string;
  timestampValue: string;  // String decimal
  uint64Value: string;  // String decimal
  sint64Value: string;  // String decimal
  booleanValue: boolean;
  aggregateValue: AggregateValue;
  arrayValue: Value[];
}

// An aggregate value is an ordered list of (member name, member value).
// Two arrays are used in order to be able to send just the values (since
// the names will not change)
interface AggregateValue {
  name: string[];
  value: Value[];
}

enum QueueState {
  BLOCKED = "BLOCKED",
  DISABLED = "DISABLED",
  ENABLED = "ENABLED",
}

enum SignificanceLevelType {
  NONE = "NONE",
  WATCH = "WATCH",
  WARNING = "WARNING",
  DISTRESS = "DISTRESS",
  CRITICAL = "CRITICAL",
  SEVERE = "SEVERE",
}

enum Type {
  FLOAT = "FLOAT",
  DOUBLE = "DOUBLE",
  UINT32 = "UINT32",
  SINT32 = "SINT32",
  BINARY = "BINARY",
  STRING = "STRING",
  TIMESTAMP = "TIMESTAMP",
  UINT64 = "UINT64",
  SINT64 = "SINT64",
  BOOLEAN = "BOOLEAN",
  AGGREGATE = "AGGREGATE",
  ARRAY = "ARRAY",

  // Enumerated values have both an integer (sint64Value) and a string representation
  ENUMERATED = "ENUMERATED",
  NONE = "NONE",
}