Query Task Status

The JobStatusChecker is designed to monitor the status of asynchronous jobs through a WebSocket connection.

The status channel is based on Socket.IO instead of standard WebSocket.

Workflow

1. Initialization: Establish a WebSocket connection to the server using the base_url and subscription_key.

2. Request Handling:

   • On a successful connection, initiate status queries with the specified job with its uuid.

3. Status Monitoring:

   • Periodically send status queries to the server, we recommend submitting queries at 2-second intervals.

   • Listen for responses from the server and update the job status accordingly.

   • If the job is completed successfully, perform necessary cleanup actions such as closing the connection.

API Endpoint

Socket /api/scheduler_socket

Queries

Name	Value
subscription	subscripton_key

Sending a Query

To query the status of a job, send a message to the scheduler socket endpoint with the job's UUID:

// Establish connection with the scheduler socket
const socket = io('/api/scheduler_socket?subscription={subscripton_key}');

// Send a query for the job status
socket.emit('query', '{job_uuid}');

Receiving a Response

The server responds with the status of the job, including details such as the job's UUID, status, and any relevant metrics.

socket.on('message', (data) => {
  console.log('Received response:', data);
  /*
    Output will be:
    {
      "taskUuid": "{job_uuid}",
      "jobStatus": "Succeeded", // Succeeded, Running, Failed
      "jobMetricPayload": {
        "status": "Done",
        "error": "None",
        "message": "Process Done",
        "percentage": 100
      }
    }
  */
});

While the specific implementation can vary, the core functionality typically involves:

• A WebSocket client that handles the lifecycle of the connection and communication.

• Event handlers that react to changes in the connection status and incoming messages.

• A mechanism to periodically send requests to the server to check the status of the job.

Examples

Python

import socketio
import time

class JobStatusChecker:
    def __init__(self, base_url, subscription_key, uuid):
        self.base_url = base_url
        self.subscription_key = subscription_key
        self.uuid = uuid
        self.sio = socketio.Client(logger=True, engineio_logger=True)

        @self.sio.event
        def connect():
            print("Connected to the server.")
            self.send_query() 
            threading.Thread(target=self.send_periodic_queries).start() 

        @self.sio.event
        def disconnect():
            print("Disconnected from server.")

        @self.sio.on('message', namespace='*')
        def message(*args, **kwargs):
            if len(args) > 2:
                data = args[2]
                if data.get('jobStatus') == 'Succeeded':
                    print("Job Succeeded! Please find the SDF image in history")
                    self.sio.disconnect()
            else:
                print("Received event with insufficient arguments.")

    def send_query(self):
        self.sio.emit('query', self.uuid, namespace='/api/scheduler_socket')

    def send_periodic_queries(self):
        while True:
            time.sleep(3)
            self.send_query()

    def start(self):
        self.sio.connect(f"{self.base_url}/scheduler_socket?subscription={self.subscription_key}", 
                         namespaces=['/api/scheduler_socket'], transports='websocket')
        self.sio.wait()
        
# Check progress
progress_checker = JobStatusChecker(BASE_URL, 'subscription_key', 'task_uuid')
progress_checker.start()

Go

package main

import (
	"encoding/json"
	"fmt"
	"net/http"
)

const BaseURI = "https://hyperhuman.deemos.com/api"

type TaskStatus string

const (
	Created       TaskStatus = "Created"
	Waiting       TaskStatus = "Waiting"
	Canceled      TaskStatus = "Canceled"
	NeedSelection TaskStatus = "NeedSelection"
	Generating    TaskStatus = "Generating"
	Done          TaskStatus = "Done"
	Failed        TaskStatus = "Failed"
)

type CheckProgressResponse struct {
	Stage      TaskStatus `json:"stage"`
	Message    *string    `json:"message,omitempty"`
	Percentage *float32   `json:"percentage,omitempty"`
	WaitingNum *int       `json:"waiting_num,omitempty"`
	Candidates []string   `json:"candidates,omitempty"`
	OnProgress []string   `json:"on_progress,omitempty"`
}

func CheckProgress(token string, uuid string) (*CheckProgressResponse, error) {
	req, err := http.NewRequest("POST", fmt.Sprintf("%s/task/check_progress/%s", BaseURI, uuid), nil)
	if err != nil {
		return nil, err
	}

	req.Header.Set("Authorization", "Bearer "+token)
	req.Header.Set("Content-Type", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	var responseData CheckProgressResponse
	err = json.NewDecoder(resp.Body).Decode(&responseData)
	if err != nil {
		return nil, err
	}

	return &responseData, nil
}

func main() {
	// Replace with your actual API key
	token := "your api key"
	// Replace with the task uuid
	resp, _ := CheckProgress(token, "task uuid")
	fmt.Println(resp)
}