rapidgrpc.proto

// File: rapidgrpc.proto
// This file describes the gRPC interface for RapidServer servers.
 
syntax = "proto3";
package RSI.RapidServer;
import "google/protobuf/timestamp.proto";
import "google/protobuf/any.proto";
 
/*** Common Message Fields ***/
message RequestHeader {
  // The time the client sent the request (according to the client's clock).
  google.protobuf.Timestamp time_sent = 1;
  
  // The name of the client.
  string client_name = 2;
 
  // A way to speed up calls by skipping populating response data.
  optional ResponseOptimization optimization = 3;
}
 
message ResponseOptimization {
  optional bool skip_config = 1;
  optional bool skip_info = 2;
  optional bool skip_status = 3;
}
 
message ErrorSource {
  // Object index (0-based index of the object that has the error)
  int32 object_index = 1;
  
  // Whether the error is or is not a warning.
  bool is_warning = 2;
  
  // Source file name.
  string file_name = 3;
 
  // The name of the function that raised the error.
  string method_name = 4;
  
  // The line number in the source code
  int32 line_number = 5;
}
 
message ErrorMessage {
  // An error that occured on the server while executing the remote procedure call.
  string message = 1;
  
  // An error code. Will have to be casted to the appropriate enum type.
  int32 code = 2;
 
  // The human-readable name of the error code.
  string code_name = 3;
 
  ErrorSource source = 4;
}
 
message ResponseHeader {
  // Return the RequestHeader back to the client.
  RequestHeader request_header = 1;
 
  // The time the server received the request (according to the server's clock).
  google.protobuf.Timestamp time_request_received = 2;
 
  // The time the server send the response (according to the server's clock).
  google.protobuf.Timestamp time_response_sent = 3;
 
  // Errors to report back to the client.
  repeated ErrorMessage errors = 4;
 
  // Return the request message to the client.
  google.protobuf.Any request = 5;
}
 
enum Platform {
  PLATFORM_UNSPECIFIED = 0;
  LINUX = 1;
  INTIME = 2;
  WINDOWS = 3;
}
 
/*** ServerControlService ***/
 
service ServerControlService {
 
  // Get details about the server such as the ID, the URI it accepts gRPC
  // requests on, and its human-readable name.
  rpc GetInfo (ServerGetInfoRequest) returns (ServerGetInfoResponse);
 
  // Shuts down the Server
  rpc Shutdown (ServerShutdownRequest) returns (ServerShutdownResponse);
 
  // Updates the server and the RMP to the specified version
  rpc Update (ServerUpdateRequest) returns (ServerUpdateResponse);
 
  // Restart the server. Can restart a new instance from a specified directory.
  rpc Restart (ServerRestartRequest) returns (ServerRestartResponse);
 
  // Reserve the server. Intended for RSI internal use only.
  rpc Reserve (ServerReserveRequest) returns (ServerReserveResponse);
 
  // Get a file from the server.
  rpc GetFile (ServerFileRequest) returns (stream FileChunk);
 
  // Send a file to the server
  rpc SendFile (stream FileChunk) returns (ServerSendFileResponse);
 
  // Check if a file exists on the server's host filesystem.
  rpc FileExists (ServerFileRequest) returns (ServerFileExistsResponse);
 
  // Delete a file from the server's host filesystem.
  rpc DeleteFile (ServerFileRequest) returns (ServerDeleteFileResponse);
}
 
message ServerShutdownRequest {
  // Common request header.
  RequestHeader header = 1;
}
 
message ServerShutdownResponse {
  // Common response header. Always check the response header for errors.
  ResponseHeader header = 1;
}
 
message ServerGetInfoRequest {
  // Common request header.
  RequestHeader header = 1;
}
 
message ServerReservation {
  // A unique identifier for the reserved session between the client and the RapidServer.
  // This field will be 0 if the server currently has not active reservation.
  uint64 session_id = 1;
}
 
message ServerGetInfoResponse {
  // Common response header. Always check the response header for errors.
  ResponseHeader header = 1;
 
  // Timestamp of when this server was started
  google.protobuf.Timestamp time_started = 2;
 
  // ID of the server
  uint64 id = 3;
 
  // The friendly name of the server
  string name = 4;
 
  // The version of the server
  string version = 5;
 
  // The server's current reservation information
  ServerReservation reservation = 6;
 
  // The platform (or operating system) the server is running on
  Platform platform = 7;
}
 
message ServerUpdateRequest {
  // Common request header.
  RequestHeader header = 1;
 
  // The version of RMP to download from the RSI downloads site. 
  // The version must be in the format: <major version number>.<minor version number>.<revision number>
  // An example version would be: "10.3.10"
  optional string download_version = 2;
 
  // The source to start a new RapidServer from.
  // If set to a URI of an RMP zip archive, the zip will be downloaded and the new version of the 
  // RapidServer will be extracted to the directory specified in the destination field.
  // If set to a zip file located on the local filesystem, the new version of the RapidServer will
  // be extracted to the directory specified in the destination field.
  // If set to a directory, a new instance of the RapidServer will be started from the given directory.
  // This field is only used if the download version is not specified.
  optional string source = 3;
 
  // The directory to extract the contents of the zip archive to.
  // If this field is not set or is an empty string, the contents will be extracted to the current directory.
  // If the directory doesn't exist, the server will attempt to create it.
  optional string destination = 4;
}
 
message ServerUpdateResponse {
  // Common response header. Always check the response header for errors.
  ResponseHeader header = 1;
}
 
message ServerRestartRequest {
  // Common request header.
  RequestHeader header = 1;
 
  // The directory to restart the RapidServer from.
  // If this field is not specified, the RapidServer will just start from
  // the current directory.
  optional string start_directory = 2;
}
 
message ServerRestartResponse {
  // Common response header. Always check the response header for errors.
  ResponseHeader header = 1;
}
 
message ServerReserveRequest {
  // Common request header.
  RequestHeader header = 1;
 
  // Set this boolean to true to release the currently active reservation.
  optional bool release = 2;
 
  // Set this boolean to true to make a new reservation.
  // This will override the existing reservation.
  optional bool reserve = 3;
}
 
message ServerReserveResponse {
  // Common response header. Always check the response header for errors.
  ResponseHeader header = 1;
 
  // The ticket containing information about the reservation session.
  ServerReservation reservation = 2;
}
 
message ServerFileRequest {
  // Common request header.
  RequestHeader header = 1;
 
  // The path to the file
  string path = 2;
}
 
message FileChunk {
  // The contents of the message
  oneof content {
    // The raw data to be sent.
    bytes data = 1;
 
    // The name to save the file with. 
    // When the server sees a FileChunk message with this field instead of the data field,
    // it will finish its work with the previous file and begin to write to the file with this name instead.
    string name = 2;
  }
}
 
message ServerSendFileResponse {
  // Common response header. Always check the response header for errors.
  ResponseHeader header = 1;
}
 
message ServerFileExistsResponse {
  // Common response header. Always check the response header for errors.
  ResponseHeader header = 1;
 
  // True if the file exists, false otherwise.
  bool exists = 2;
}
 
message ServerDeleteFileResponse {
  // Common response header. Always check the response header for errors.
  ResponseHeader header = 1;
}