SambaNova Management Layer (SNML)

# Import the Python gRPC data structures and functions
# These should be available on a DataScale system with the `sambanova-runtime` package installed
from pysnml.snml_rpc_pb2 import *
from pysnml.snml_rpc_pb2_grpc import *

# assume SNML is configured as default
SERVER_HOST = 127.0.0.1
SERVER_PORT = 50053

# Connect to the SNML server on this DataScale system
with grpc.insecure_channel(f'{SERVER_HOST}:{SERVER_PORT}') as channel:
        # A gRPC stub for the SNML RPC service - generated for us by gRPC's Python code
        stub = SNMLRPCStub(channel)

        # Call the API. The `request_id` field is provided for the caller's consumption
        # The `request_id` in the response type will be the same as the one provided
        # This is useful when the caller is sending multiple requests and wants to keep track
        # In this example, we'll just pass 0.
        query_response = stub.GetRuntimeVersion(
            ResourceQuery(request_id=0))

        # This object will have the following fields:
        # - platform_name (str): the platform name "DataScale SN30-8"
        # - request_id (int): the request ID provided by the caller
        # - error_details (list of str): A list of strings specifying any errors that
        #   happened during the calling of this API. If no errors occurred, this list is empty
        # - ver_info (SystemVersionInfo): the version information of the SNFM databases
        #   on this system. Mostly not interesting to consumers.
        print(query_response)

# Import the Python gRPC data structures and functions
# These should be available on DataScale systems with the sambanova-runtime package installed
from pysnml.snml_rpc_pb2 import *
from pysnml.snml_rpc_pb2_grpc import *

# assume SNML is configured as default
SERVER_HOST = 127.0.0.1
SERVER_PORT = 50053

# Connect to the SNML server on this DataScale system
with grpc.insecure_channel(f'{SERVER_HOST}:{SERVER_PORT}') as channel:
    # A gRPC stub for the SNML RPC service
    stub = SNMLRPCStub(channel)

    # Each RDU has a component name like "XRDU_0/RDU_1"
    # It also has a unique 1-number identifier created from its component name.
    # To calculate the 1-number identifier, multiply the (XRDU number) by the
    # (number of RDUs per XRDU) [2]
    # and add the RDU number within the XRDU
    # This list reflects "XRDU_0/RDU_0" and "XRDU_0/RDU_1"
    rdu_ids = [0, 1]

    # Request the operational status of the RDUs we listed above
    query_response = stub.GetRDUOperationalStatus(
        RDUOperationalStatusRequest(request_id=0,
                                    rdu_ids=rdu_ids))

    # This is a generator object. You can iterate through it,
    # but it is not subscriptible
    for rdu in query_response:
        # The RDU ID is as specified above
        # The `comp_name` is something like "/NODE/XRDU_0/RDU_1"
        # The state is an enum with one of the following values:
        #    - RDU_STATE_FUNCTIONAL
        #    - RDU_STATE_PENDING
        #    - RDU_STATE_DEGRADED
        #    - RDU_STATE_UNAVAILABLE
        print(rdu.rdu_id, rdu.comp_name,
              RDUOperationalState.Name(rdu.state))

# Retrieving RDU operational state is a "plain" SNML API
# No root privileges are required
from pysnml.snml_rpc_pb2 import *
from pysnml.snml_rpc_pb2_grpc import *

# Requesting RDU resets is an SNML Admin API
# Callers require root privileges and will be checked by the server-side
from pysnml.snml_rpc_admin_pb2 import *
from pysnml.snml_rpc_admin_pb2_grpc import *

import time
import sys

# assume SNML is configured as default
SERVER_HOST = "127.0.0.1"
SERVER_PORT = 50053


with grpc.insecure_channel(f'{SERVER_HOST}:{SERVER_PORT}') as channel:
    # Connect to the SNML admin and SNML servers
    # Each service requries a Stub
    stub = SNMLRPCStub(channel)
    admin_stub = SNMLRPCADMINStub(channel)

    # Launch an asynchronous RDU reset
    # The field wait_for_reinit being set to false tells SND to launch the RDU's
    # post-reset intialization in the background
    # We will poll on the RDU's operational state later to
    # make sure that the reset finishes successfully.
    # Alternatively, `wait_for_reinit=True` tells SND to not return from this query
    # until the reset succeeds or fails
    rst_query_response = admin_stub.ManualRDUReset(
            ManualRDUResetRequest(request_id=0,
                                  rdus_to_reset=[1], # Reset RDU 1 (XRDU_0/RDU_1)
                                  wait_for_reinit=False))
    print("Requested SND to reset RDU")


    # Request the RDU's operational status
    query_response = stub.GetRDUOperationalStatus(
        RDUOperationalStatusRequest(request_id=0,
                                    rdu_ids=[1]))
    print("Requested RDU's operational status from SND")


    # The RDU will be in state RDU_STATE_PENDING while the reset is in progress
    # And will return to RDU_STATE_FUNCTIONAL after it's complete
    while True: # you could specify a maximum number of iterations here
        for rdu in query_response:
            print(f"RDU {rdu.rdu_id} in state {RDUOperationalState.Name(rdu.state)}")
            if RDUOperationalState.Name(rdu.state) == "RDU_STATE_FUNCTIONAL":
                print("Successfully reset and polled status of RDU 1")
                sys.exit(0)

        time.sleep(5)