[Task] Implement of connecting between actioncontroller and pharos #144

src/common/build.rs

@@ -10,5 +10,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     tonic_build::compile_protos("proto/nodeagent.proto")?;
     tonic_build::compile_protos("proto/policymanager.proto")?;
     tonic_build::compile_protos("proto/statemanager.proto")?;
+    tonic_build::compile_protos("proto/pharos_service.proto")?;
     Ok(())
 }

src/common/proto/actioncontroller.proto

@@ -10,6 +10,7 @@ package actioncontroller;
 service ActionControllerConnection {
   rpc TriggerAction(TriggerActionRequest) returns (TriggerActionResponse);
   rpc Reconcile(ReconcileRequest) returns (ReconcileResponse);
+  rpc CompleteNetworkSetting(CompleteNetworkSettingRequest) returns (CompleteNetworkSettingResponse);
 }
 
 message TriggerActionRequest {
@@ -23,16 +24,32 @@ message TriggerActionResponse {
 
 message ReconcileRequest {
   string scenario_name = 1;
-  Status current = 2;
-  Status desired = 3;
+  PodStatus current = 2;
+  PodStatus desired = 3;
 }
 
 message ReconcileResponse {
   int32 status = 1;
   string desc = 2;
 }
 
-enum Status {
+message CompleteNetworkSettingRequest {
+  string request_id = 1;
+  NetworkStatus network_status = 2;
+  PodStatus pod_status = 3;
+  string details = 4;
+}
+message CompleteNetworkSettingResponse {
+  bool acknowledged = 1;
+}
+
+enum NetworkStatus {
+  OK = 0;
+  ERROR = 1;
+  TIMEOUT = 2;
+}
+
+enum PodStatus {
   NONE = 0;
   INIT = 1;
   READY = 2;

src/common/proto/pharos_service.proto

@@ -0,0 +1,22 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2024 LG Electronics Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+syntax = "proto3";
+package pharos.api.v1;
+
+service PharosNetworkServiceConnection {
+  rpc RequestNetworkPod(RequestNetworkPodRequest) returns (RequestNetworkPodResponse);
+}
+
+message RequestNetworkPodRequest {
+  string node_yaml = 1;
+  string pod_name = 2;
+  string networkYamls = 3;
+}
+message RequestNetworkPodResponse {
+  string request_id = 1;
+  bool accepted = 2;
+  string message = 3;
+}

src/common/src/lib.rs

@@ -129,6 +129,12 @@ pub mod statemanager {
     }
 }
 
+pub mod pharos_service {
+    tonic::include_proto!("pharos.api.v1");
+    pub fn connect_pharos_server() -> String {
+        format!("http://{}:{}", crate::setting::get_config().host.ip, 47006)
+    }
+}
 //Unit Test Cases
 #[cfg(test)]
 mod tests {

src/common/src/spec/artifact/mod.rs

@@ -1,5 +1,6 @@
 mod model;
 mod network;
+mod node;
 mod package;
 mod scenario;
 mod volume;
@@ -45,6 +46,14 @@ pub struct Network {
     spec: Option<network::NetworkSpec>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+pub struct Node {
+    apiVersion: String,
+    kind: String,
+    metadata: MetaData,
+    spec: Option<node::NodeSpec>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct Model {
     apiVersion: String,

src/common/src/spec/artifact/node.rs

@@ -0,0 +1,25 @@
+use super::Artifact;
+use super::Node;
+
+impl Artifact for Node {
+    fn get_name(&self) -> String {
+        self.metadata.name.clone()
+    }
+}
+
+impl Node {
+    pub fn get_spec(&self) -> &Option<NodeSpec> {
+        &self.spec
+    }
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize, PartialEq)]
+pub struct NodeSpec {
+    dummy: Option<String>,
+}
+
+impl NodeSpec {
+    pub fn get_node(&self) -> &Option<String> {
+        &self.dummy
+    }
+}

src/player/actioncontroller/src/grpc/receiver.rs

@@ -6,8 +6,8 @@ use common::actioncontroller::{
     action_controller_connection_server::{
         ActionControllerConnection, ActionControllerConnectionServer,
     },
-    ReconcileRequest, ReconcileResponse, Status as ActionStatus, TriggerActionRequest,
-    TriggerActionResponse,
+    CompleteNetworkSettingRequest, CompleteNetworkSettingResponse, ReconcileRequest,
+    ReconcileResponse, PodStatus as ActionStatus, NetworkStatus, TriggerActionRequest, TriggerActionResponse,
 };
 
 /// Receiver for handling incoming gRPC requests for ActionController
@@ -143,6 +143,20 @@ impl ActionControllerConnection for ActionControllerReceiver {
             }
         }
     }
+
+    async fn complete_network_setting(
+        &self,
+        request: Request<CompleteNetworkSettingRequest>,
+    ) -> Result<Response<CompleteNetworkSettingResponse>, Status> {
+        let req = request.into_inner();
+        println!(
+            "CompleteNetworkSettingRequest: request_id={}, network_status={:?}, pod_status={:?}, details={}",
+            req.request_id, req.network_status, req.pod_status, req.details
+        );
+
+        let response = CompleteNetworkSettingResponse { acknowledged: true };
+        Ok(Response::new(response))
+    }
 }
 
 fn i32_to_status(value: i32) -> ActionStatus {

src/player/actioncontroller/src/grpc/sender/mod.rs

@@ -0,0 +1,9 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2024 LG Electronics Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//! Running gRPC message sending
+
+pub mod pharos;
+pub mod policymanager;

src/player/actioncontroller/src/grpc/sender/pharos.rs

@@ -0,0 +1,43 @@
+/*
+ * SPDX-FileCopyrightText: Copyright 2024 LG Electronics Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+//! Running gRPC message sending to pharos
+
+use common::pharos_service::{
+    connect_pharos_server,
+    pharos_network_service_connection_client::PharosNetworkServiceConnectionClient,
+    RequestNetworkPodRequest, RequestNetworkPodResponse,
+};
+
+use std::collections::HashMap;
+use tonic::{Request, Response, Status};
+
+/// Send request to Pharos to set up network for a pod
+///
+/// ### Parameters
+/// * `node_yaml` - YAML representation of the node
+/// * `pod_name` - Name of the pod
+/// * `network_yamls` - Map of network configurations
+/// ### Returns
+/// * `Result<Response<RequestNetworkPodResponse>, Status>` - Response from Pharos
+/// ### Description
+/// Connects to Pharos service and requests network configuration for a pod
+pub async fn request_network_pod(
+    node_yaml: String,
+    pod_name: String,
+    network_yamls: String,
+) -> Result<Response<RequestNetworkPodResponse>, Status> {
+    println!("Connecting to Pharos server ....");
+    // Create the request
+    let request = RequestNetworkPodRequest {
+        node_yaml,
+        pod_name,
+        network_yamls,
+    };
+    let mut client = PharosNetworkServiceConnectionClient::connect(connect_pharos_server())
+        .await
+        .unwrap();
+    client.request_network_pod(Request::new(request)).await
+}

src/player/actioncontroller/src/manager.rs

@@ -1,9 +1,9 @@
 use std::{thread, time::Duration};
 
-use crate::runtime::bluechi;
+use crate::{grpc::sender::pharos::request_network_pod, runtime::bluechi};
 use common::{
-    actioncontroller::Status,
-    spec::artifact::{Package, Scenario},
+    actioncontroller::PodStatus as Status,
+    spec::artifact::{Network, Node, Package, Scenario},
     Result,
 };
 
@@ -111,6 +111,23 @@ impl ActionControllerManager {
             )
         })?;
 
+        // To Do.. network, node yaml extract from etcd.
+        let etcd_network_key = format!("Network/{}", scenario_name);
+        let network_str = match common::etcd::get(&etcd_network_key).await {
+            Ok(value) => value,
+            Err(e) => {
+                return Err(format!("Network key '{}' not found: {}", etcd_network_key, e).into());
+            }
+        };
+
+        let etcd_node_key = format!("Node/{}", scenario_name);
+        let node_str = match common::etcd::get(&etcd_node_key).await {
+            Ok(value) => value,
+            Err(e) => {
+                return Err(format!("Network key '{}' not found: {}", etcd_node_key, e).into());
+            }
+        };
+
         for mi in package.get_models() {
             let model_name = format!("{}.service", mi.get_name());
             let model_node = mi.get_node();
@@ -133,6 +150,15 @@ impl ActionControllerManager {
                     self.start_workload(&model_name, &model_node, &node_type)
                         .await
                         .map_err(|e| format!("Failed to start workload '{}': {}", model_name, e))?;
+                    request_network_pod(
+                        node_str.clone(),
+                        scenario_name.to_string(),
+                        network_str.clone(),
+                    )
+                    .await
+                    .map_err(|e| {
+                        format!("Failed to request network pod for '{}': {}", model_name, e)
+                    })?;
                 }
                 "terminate" => {
                     self.reload_all_node(&model_name, &model_node).await?;

src/server/apiserver/src/artifact/mod.rs

@@ -10,6 +10,7 @@ pub mod data;
 use common::spec::artifact::Artifact;
 use common::spec::artifact::Model;
 use common::spec::artifact::Network;
+use common::spec::artifact::Node;
 use common::spec::artifact::Package;
 use common::spec::artifact::Scenario;
 use common::spec::artifact::Volume;
@@ -26,7 +27,6 @@ pub async fn apply(body: &str) -> common::Result<String> {
     let docs: Vec<&str> = body.split("---").collect();
     let mut scenario_str = String::new();
     let mut package_str = String::new();
-    let mut network_str = String::new();
 
     for doc in docs {
         let value: serde_yaml::Value = serde_yaml::from_str(doc)?;
@@ -38,6 +38,7 @@ pub async fn apply(body: &str) -> common::Result<String> {
                 "Package" => serde_yaml::from_value::<Package>(value)?.get_name(),
                 "Volume" => serde_yaml::from_value::<Volume>(value)?.get_name(),
                 "Network" => serde_yaml::from_value::<Network>(value)?.get_name(),
+                "Node" => serde_yaml::from_value::<Node>(value)?.get_name(),
                 "Model" => serde_yaml::from_value::<Model>(value)?.get_name(),
                 _ => {
                     println!("unknown artifact");
@@ -50,7 +51,6 @@ pub async fn apply(body: &str) -> common::Result<String> {
             match kind {
                 "Scenario" => scenario_str = artifact_str,
                 "Package" => package_str = artifact_str,
-                //"Network" => network_str = artifact_str,
                 _ => continue,
             };
         }