// Copyright 2021-2023 H2020 TeraFlow (https://www.teraflow-h2020.eu/)
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

syntax = "proto3";
package context;

import "acl.proto";
import "kpi_sample_types.proto";

service ContextService {
  rpc ListContextIds     (Empty       ) returns (       ContextIdList   ) {}
  rpc ListContexts       (Empty       ) returns (       ContextList     ) {}
  rpc GetContext         (ContextId   ) returns (       Context         ) {}
  rpc SetContext         (Context     ) returns (       ContextId       ) {}
  rpc RemoveContext      (ContextId   ) returns (       Empty           ) {}
  rpc GetContextEvents   (Empty       ) returns (stream ContextEvent    ) {}

  rpc ListTopologyIds    (ContextId   ) returns (       TopologyIdList  ) {}
  rpc ListTopologies     (ContextId   ) returns (       TopologyList    ) {}
  rpc GetTopology        (TopologyId  ) returns (       Topology        ) {}
  rpc SetTopology        (Topology    ) returns (       TopologyId      ) {}
  rpc RemoveTopology     (TopologyId  ) returns (       Empty           ) {}
  rpc GetTopologyEvents  (Empty       ) returns (stream TopologyEvent   ) {}

  rpc ListDeviceIds      (Empty       ) returns (       DeviceIdList    ) {}
  rpc ListDevices        (Empty       ) returns (       DeviceList      ) {}
  rpc GetDevice          (DeviceId    ) returns (       Device          ) {}
  rpc SetDevice          (Device      ) returns (       DeviceId        ) {}
  rpc RemoveDevice       (DeviceId    ) returns (       Empty           ) {}
  rpc GetDeviceEvents    (Empty       ) returns (stream DeviceEvent     ) {}

  rpc ListLinkIds        (Empty       ) returns (       LinkIdList      ) {}
  rpc ListLinks          (Empty       ) returns (       LinkList        ) {}
  rpc GetLink            (LinkId      ) returns (       Link            ) {}
  rpc SetLink            (Link        ) returns (       LinkId          ) {}
  rpc RemoveLink         (LinkId      ) returns (       Empty           ) {}
  rpc GetLinkEvents      (Empty       ) returns (stream LinkEvent       ) {}

  rpc ListServiceIds     (ContextId   ) returns (       ServiceIdList   ) {}
  rpc ListServices       (ContextId   ) returns (       ServiceList     ) {}
  rpc GetService         (ServiceId   ) returns (       Service         ) {}
  rpc SetService         (Service     ) returns (       ServiceId       ) {}
  rpc RemoveService      (ServiceId   ) returns (       Empty           ) {}
  rpc GetServiceEvents   (Empty       ) returns (stream ServiceEvent    ) {}

  rpc ListSliceIds       (ContextId   ) returns (       SliceIdList     ) {}
  rpc ListSlices         (ContextId   ) returns (       SliceList       ) {}
  rpc GetSlice           (SliceId     ) returns (       Slice           ) {}
  rpc SetSlice           (Slice       ) returns (       SliceId         ) {}
  rpc RemoveSlice        (SliceId     ) returns (       Empty           ) {}
  rpc GetSliceEvents     (Empty       ) returns (stream SliceEvent      ) {}

  rpc ListConnectionIds  (ServiceId   ) returns (       ConnectionIdList) {}
  rpc ListConnections    (ServiceId   ) returns (       ConnectionList  ) {}
  rpc GetConnection      (ConnectionId) returns (       Connection      ) {}
  rpc SetConnection      (Connection  ) returns (       ConnectionId    ) {}
  rpc RemoveConnection   (ConnectionId) returns (       Empty           ) {}
  rpc GetConnectionEvents(Empty       ) returns (stream ConnectionEvent ) {}
}

// ----- Generic -------------------------------------------------------------------------------------------------------
message Empty {}

message Uuid {
  string uuid = 1;
}

enum EventTypeEnum {
  EVENTTYPE_UNDEFINED = 0;
  EVENTTYPE_CREATE = 1;
  EVENTTYPE_UPDATE = 2;
  EVENTTYPE_REMOVE = 3;
}

message Timestamp {
  double timestamp = 1;
}

message Event {
  Timestamp timestamp = 1;
  EventTypeEnum event_type = 2;
}

// ----- Context -------------------------------------------------------------------------------------------------------
message ContextId {
  Uuid context_uuid = 1;
}

message Context {
  ContextId context_id = 1;
  repeated TopologyId topology_ids = 2;
  repeated ServiceId service_ids = 3;
  TeraFlowController controller = 4;
}

message ContextIdList {
  repeated ContextId context_ids = 1;
}

message ContextList {
  repeated Context contexts = 1;
}

message ContextEvent {
  Event event = 1;
  ContextId context_id = 2;
}


// ----- Topology ------------------------------------------------------------------------------------------------------
message TopologyId {
  ContextId context_id = 1;
  Uuid topology_uuid = 2;
}

message Topology {
  TopologyId topology_id = 1;
  repeated DeviceId device_ids = 2;
  repeated LinkId link_ids = 3;
}

message TopologyIdList {
  repeated TopologyId topology_ids = 1;
}

message TopologyList {
  repeated Topology topologies = 1;
}

message TopologyEvent {
  Event event = 1;
  TopologyId topology_id = 2;
}


// ----- Device --------------------------------------------------------------------------------------------------------
message DeviceId {
  Uuid device_uuid = 1;
}

message Device {
  DeviceId device_id = 1;
  string device_type = 2;
  DeviceConfig device_config = 3;
  DeviceOperationalStatusEnum device_operational_status = 4;
  repeated DeviceDriverEnum device_drivers = 5;
  repeated EndPoint device_endpoints = 6;
}

message DeviceConfig {
  repeated ConfigRule config_rules = 1;
}

enum DeviceDriverEnum {
  DEVICEDRIVER_UNDEFINED = 0; // also used for emulated
  DEVICEDRIVER_OPENCONFIG = 1;
  DEVICEDRIVER_TRANSPORT_API = 2;
  DEVICEDRIVER_P4 = 3;
  DEVICEDRIVER_IETF_NETWORK_TOPOLOGY = 4;
  DEVICEDRIVER_ONF_TR_352 = 5;
}

enum DeviceOperationalStatusEnum {
  DEVICEOPERATIONALSTATUS_UNDEFINED = 0;
  DEVICEOPERATIONALSTATUS_DISABLED = 1;
  DEVICEOPERATIONALSTATUS_ENABLED = 2;
}

message DeviceIdList {
  repeated DeviceId device_ids = 1;
}

message DeviceList {
  repeated Device devices = 1;
}

message DeviceEvent {
  Event event = 1;
  DeviceId device_id = 2;
}


// ----- Link ----------------------------------------------------------------------------------------------------------
message LinkId {
  Uuid link_uuid = 1;
}

message Link {
  LinkId link_id = 1;
  repeated EndPointId link_endpoint_ids = 2;
}

message LinkIdList {
  repeated LinkId link_ids = 1;
}

message LinkList {
  repeated Link links = 1;
}

message LinkEvent {
  Event event = 1;
  LinkId link_id = 2;
}


// ----- Service -------------------------------------------------------------------------------------------------------
message ServiceId {
  ContextId context_id = 1;
  Uuid service_uuid = 2;
}

message Service {
  ServiceId service_id = 1;
  ServiceTypeEnum service_type = 2;
  repeated EndPointId service_endpoint_ids = 3;
  repeated Constraint service_constraints = 4;
  ServiceStatus service_status = 5;
  ServiceConfig service_config = 6;
  Timestamp timestamp = 7;
}

enum ServiceTypeEnum {
  SERVICETYPE_UNKNOWN = 0;
  SERVICETYPE_L3NM = 1;
  SERVICETYPE_L2NM = 2;
  SERVICETYPE_TAPI_CONNECTIVITY_SERVICE = 3;
}

enum ServiceStatusEnum {
  SERVICESTATUS_UNDEFINED = 0;
  SERVICESTATUS_PLANNED = 1;
  SERVICESTATUS_ACTIVE =  2;
  SERVICESTATUS_PENDING_REMOVAL = 3;
  SERVICESTATUS_SLA_VIOLATED = 4;
}

message ServiceStatus {
  ServiceStatusEnum service_status = 1;
}

message ServiceConfig {
  repeated ConfigRule config_rules = 1;
}

message ServiceIdList {
  repeated ServiceId service_ids = 1;
}

message ServiceList {
  repeated Service services = 1;
}

message ServiceEvent {
  Event event = 1;
  ServiceId service_id = 2;
}

// ----- Slice ---------------------------------------------------------------------------------------------------------
message SliceId {
  ContextId context_id = 1;
  Uuid slice_uuid = 2;
}

message Slice {
  SliceId slice_id = 1;
  repeated EndPointId slice_endpoint_ids = 2;
  repeated Constraint slice_constraints = 3;
  repeated ServiceId slice_service_ids = 4;
  repeated SliceId slice_subslice_ids = 5;
  SliceStatus slice_status = 6;
  SliceConfig slice_config = 7;
  SliceOwner slice_owner = 8;
  Timestamp timestamp = 9;
}

message SliceOwner {
  Uuid owner_uuid = 1;
  string owner_string = 2;
}

enum SliceStatusEnum {
  SLICESTATUS_UNDEFINED = 0;
  SLICESTATUS_PLANNED   = 1;
  SLICESTATUS_INIT      = 2;
  SLICESTATUS_ACTIVE    = 3;
  SLICESTATUS_DEINIT    = 4;
  SLICESTATUS_SLA_VIOLATED = 5;
}

message SliceStatus {
  SliceStatusEnum slice_status = 1;
}

message SliceConfig {
  repeated ConfigRule config_rules = 1;
}

message SliceIdList {
  repeated SliceId slice_ids = 1;
}

message SliceList {
  repeated Slice slices = 1;
}

message SliceEvent {
  Event event = 1;
  SliceId slice_id = 2;
}

// ----- Connection ----------------------------------------------------------------------------------------------------
message ConnectionId {
  Uuid connection_uuid = 1;
}

message ConnectionSettings_L0 {
  string lsp_symbolic_name = 1;
}

message ConnectionSettings_L2 {
  string src_mac_address = 1;
  string dst_mac_address = 2;
  uint32 ether_type = 3;
  uint32 vlan_id = 4;
  uint32 mpls_label = 5;
  uint32 mpls_traffic_class = 6;
}

message ConnectionSettings_L3 {
  string src_ip_address = 1;
  string dst_ip_address = 2;
  uint32 dscp = 3;
  uint32 protocol = 4;
  uint32 ttl = 5;
}

message ConnectionSettings_L4 {
  uint32 src_port = 1;
  uint32 dst_port = 2;
  uint32 tcp_flags = 3;
  uint32 ttl = 4;
}

message ConnectionSettings {
  ConnectionSettings_L0 l0 = 1;
  ConnectionSettings_L2 l2 = 2;
  ConnectionSettings_L3 l3 = 3;
  ConnectionSettings_L4 l4 = 4;
}

message Connection {
  ConnectionId connection_id = 1;
  ServiceId service_id = 2;
  repeated EndPointId path_hops_endpoint_ids = 3;
  repeated ServiceId sub_service_ids = 4;
  ConnectionSettings settings = 5;
}

message ConnectionIdList {
  repeated ConnectionId connection_ids = 1;
}

message ConnectionList {
  repeated Connection connections = 1;
}

message ConnectionEvent {
  Event event = 1;
  ConnectionId connection_id = 2;
}


// ----- Endpoint ------------------------------------------------------------------------------------------------------
message EndPointId {
  TopologyId topology_id = 1;
  DeviceId device_id = 2;
  Uuid endpoint_uuid = 3;
}

message EndPoint {
  EndPointId endpoint_id = 1;
  string endpoint_type = 2;
  repeated kpi_sample_types.KpiSampleType kpi_sample_types = 3;
  Location endpoint_location = 4;
}


// ----- Configuration -------------------------------------------------------------------------------------------------
enum ConfigActionEnum {
  CONFIGACTION_UNDEFINED = 0;
  CONFIGACTION_SET = 1;
  CONFIGACTION_DELETE = 2;
}

message ConfigRule_Custom {
  string resource_key = 1;
  string resource_value = 2;
}

message ConfigRule_ACL {
  EndPointId endpoint_id = 1;
  acl.AclRuleSet rule_set = 2;
}

message ConfigRule {
  ConfigActionEnum action = 1;
  oneof config_rule {
    ConfigRule_Custom custom = 2;
    ConfigRule_ACL acl = 3;
  }
}


// ----- Constraint ----------------------------------------------------------------------------------------------------
message Constraint_Custom {
  string constraint_type = 1;
  string constraint_value = 2;
}

message Constraint_Schedule {
  float start_timestamp = 1;
  float duration_days = 2;
}

message GPS_Position {
  float latitude = 1;
  float longitude = 2;
}

message Location {
  oneof location {
    string region = 1;
    GPS_Position gps_position = 2;
  }
}

message Constraint_EndPointLocation {
  EndPointId endpoint_id = 1;
  Location location = 2;
}

message Constraint_EndPointPriority {
  EndPointId endpoint_id = 1;
  uint32 priority = 2;
}

message Constraint_SLA_Latency {
  float e2e_latency_ms = 1;
}

message Constraint_SLA_Capacity {
  float capacity_gbps = 1;
}

message Constraint_SLA_Availability {
  uint32 num_disjoint_paths = 1;
  bool all_active = 2;
}

enum IsolationLevelEnum {
  NO_ISOLATION = 0;
  PHYSICAL_ISOLATION = 1;
  LOGICAL_ISOLATION = 2;
  PROCESS_ISOLATION = 3;
  PHYSICAL_MEMORY_ISOLATION = 4;
  PHYSICAL_NETWORK_ISOLATION = 5;
  VIRTUAL_RESOURCE_ISOLATION = 6;
  NETWORK_FUNCTIONS_ISOLATION = 7;
  SERVICE_ISOLATION = 8;
}

message Constraint_SLA_Isolation_level {
  repeated IsolationLevelEnum isolation_level = 1;
}

message Constraint {
  oneof constraint {
    Constraint_Custom custom = 1;
    Constraint_Schedule schedule = 2;
    Constraint_EndPointLocation endpoint_location = 3;
    Constraint_EndPointPriority endpoint_priority = 4;
    Constraint_SLA_Capacity sla_capacity = 5;
    Constraint_SLA_Latency sla_latency = 6;
    Constraint_SLA_Availability sla_availability = 7;
    Constraint_SLA_Isolation_level sla_isolation = 8;
  }
}


// ----- Miscellaneous -------------------------------------------------------------------------------------------------
message TeraFlowController {
  ContextId context_id = 1;
  string ip_address = 2;
  uint32 port = 3;
}

message AuthenticationResult {
  ContextId context_id = 1;
  bool authenticated = 2;
}
