github.com/cloudwan/edgelq-sdk@v1.15.4/devices/proto/v1alpha2/broker_custom.proto

syntax = "proto3";

package ntt.devices.v1alpha2;

import "edgelq-sdk/devices/proto/v1alpha2/device.proto";
import "edgelq-sdk/devices/proto/v1alpha2/device_change.proto";

option go_package = "github.com/cloudwan/edgelq-sdk/devices/client/v1alpha2/broker;broker_client";
option java_multiple_files = false;
option java_outer_classname = "BrokerCustomProto";
option java_package = "com.ntt.devices.pb.v1alpha2";

// Request message for method
// [ListenForConnections][ntt.devices.v1alpha2.ListenForConnections] Registers a
// new session listener (agent) to the endpoint. This method is used by agents
// on the device and not meant for use of users.
message ListenForConnectionsRequest {
  oneof msg {
    // This is a hello message from the agent with its name.
    RegisterListener register_listener = 1;

    // When the agent failed to open a requested channel, this message will be
    // sent from the agent to the endpoint.
    ChannelOpenError channel_open_error = 2;

    // KeepAlive.
    KeepAlive keep_alive = 3;
  }

  message RegisterListener {
    // The self-declared device name, used for authentication/authorization.
    string device = 1;
  }

  message ChannelOpenError {
    // ID of the channel failed to open.
    string channel = 1;

    // Error message.
    string message = 2;
  }

  message KeepAlive {}
}

// Response message for method
// [ListenForConnections][ntt.devices.v1alpha2.ListenForConnections] Responses
// from the endpoint to session agents.
message ListenForConnectionsResponse {
  oneof msg {
    // Notifies a new channel has been requested by a client.
    ChannelRequested channel_requested = 1;

    // Keepalive
    KeepAlive keep_alive = 2;
  }

  message ChannelRequested {
    // Channel ID
    string channel = 1;

    // Device service;
    BrokerServiceType service = 2;

    // Initial argument (optional)
    string arg = 3;
  }

  message KeepAlive {}
}

// Request message for method
// [OpenConnectionChannelSocket][ntt.devices.v1alpha2.OpenConnectionChannelSocket]
// Opens a new socket for a session by agent at an endpoint. This session is
// usually initiated by the agent who received a `ChannelRequested` message on a
// ListenForConnection session. The session is used for data plane to transfer
// data for a channel between the endpoint and the agent.
message OpenConnectionChannelSocketRequest {
  oneof msg {
    // Registers a new socket on the endpoint.
    RegisterSocket register_socket = 1;

    // Data from the agent to the endpoint (client).
    bytes data = 3;

    // Error from the agent to the endpoint (client).
    bytes error = 4;

    // Ack from the agent to the endpoint (client)
    Ack ack = 5;
  }

  message RegisterSocket {
    // Device name, to be authenticated/authorized.
    string device = 1;

    // Channel ID, requested by the endpoint in the ChannelRequested message.
    string channel = 2;
  }
}

// Response message for method
// [OpenConnectionChannelSocket][ntt.devices.v1alpha2.OpenConnectionChannelSocket]
message OpenConnectionChannelSocketResponse {
  oneof msg {
    // Data from the endpoint (client) to the agent.
    bytes data = 1;

    // Ack from the client to the endpoint (device)
    Ack ack = 2;
  }
}

// Request message for method
// [ConnectToDevice][ntt.devices.v1alpha2.ConnectToDevice] ConnectToDevice
// connects a local service provided by a Device.
message ConnectToDeviceRequest {
  oneof msg {
    // The initiation message to open a channel to a device.
    OpenRequest open_request = 1;

    // Any data sent to the device through the endpoint.
    bytes data = 3;

    // Ack from the user to the endpoint (device)
    Ack ack = 4;

    KeepAlive keep_alive = 5;
  }

  message OpenRequest {
    // Device name to connect.
    string device = 1;

    // Device service
    BrokerServiceType service = 2;

    // Initial argument (optional)
    string arg = 3;
  }

  message KeepAlive {}
}

// Response message for method
// [ConnectToDevice][ntt.devices.v1alpha2.ConnectToDevice]
message ConnectToDeviceResponse {
  oneof msg {
    // Notification from the agent (endpoint) to the channel has been opened.
    OpenResponse open_response = 1;

    // Any data from the device (endpoint) to the client.
    bytes data = 3;

    // Any error from the device (endpoint) to the client.
    bytes error = 4;

    // Ack from the device to the endpoint (client)
    Ack ack = 5;
  }

  message OpenResponse {}
}

// Ack message that contains how much data should have been processed
message Ack { uint64 processed = 1; }

// Services on the device that the client connects to
message SSHService {
  message Hello {
    string user = 1;

    repeated string command = 2;

    // Environment (optional)
    map<string, string> env = 3;
  }

  message TerminalSize {
    uint32 width = 1;

    uint32 height = 2;
  }

  message ClientOut {
    oneof msg {
      bytes data = 1;

      Hello ssh_hello = 2;

      TerminalSize ssh_resize_terminal = 3;
    }
  }

  message ClientIn {
    oneof msg { bytes data = 1; }
  }
}

message SCPService {
  oneof msg {
    // Request to create a directory
    CreateDirectory dir = 1;

    // Request to create a file
    CreateFile file = 2;

    // Request to end SCP transfer
    bool eot = 3;

    // Request SCP configuration
    Configure config = 4;
  }

  message Configure {
    bool recursive = 1;

    Direction direction = 2;

    string path = 3;

    enum Direction {
      DOWNLOAD = 0;

      UPLOAD = 1;
    }
  }

  message CreateDirectory {
    string path = 1;

    uint32 mode = 2;
  }

  message CreateFile {
    oneof msg {
      // Request file initialization
      Initialize init = 1;

      // Request file data
      bytes data = 2;

      // Request to end file transfer
      bool eof = 3;
    }

    message Initialize {
      string path = 1;

      uint32 mode = 2;

      uint64 size = 3;
    }
  }
}

message LogsService {
  // Messages sent only to a device
  message ToDevice {
    // Live follow the logs service
    bool follow = 1;

    // Number of lines to get from the logs service
    uint32 lines = 2;

    // Source of the logs service (e.g. docker container ID)
    string source = 3;
  }

  // Messages sent only to a client
  message ToClient {
    // Logs data
    bytes data = 1;
  }
}

message PodManagementService {
  // Pod state command
  PodState command = 1;

  // Pod to execute the command on
  string pod = 2;

  // Service (container) name to execute the command on (empty = acts on the
  // entire pod)
  string service = 3;

  // Commands for pod state management
  enum PodState {
    // Unspecified pod state
    UNSPECIFIED = 0;

    // Start the pod
    START = 1;

    // Stop the pod
    STOP = 2;

    // Restart the pod
    RESTART = 3;
  }
}

message SystemStateService {
  // Commands for system state management
  enum SystemState {
    // Unspecified system state
    UNSPECIFIED = 0;

    // Shutdown the system
    SHUTDOWN = 1;

    // Reboot the system
    REBOOT = 2;
  }
}

// Broker dedicated messages
enum BrokerServiceType {
  // Service type not specified
  BROKER_SERVICE_UNSPECIFIED = 0;

  // SSH service
  BROKER_SERVICE_SSH_LEGACY = 1;

  BROKER_SERVICE_SSH = 3;

  // TCP port forward service
  BROKER_SERVICE_TCP_FORWARD_PORT = 2;

  // Reboot service
  BROKER_SERVICE_REBOOT = 4;

  // Shutdown service
  BROKER_SERVICE_SHUTDOWN = 5;

  // SCP service
  BROKER_SERVICE_SCP = 6;

  BROKER_SERVICE_SCP_LEGACY = 7;

  // System Logs service
  BROKER_SYS_LOGS = 8;

  // Application (Container) Logs service
  BROKER_APP_LOGS = 9;

  // Pod State Management service
  BROKER_POD_MANAGEMENT = 10;
}