Begin implement protocol

src/client/main.rs

@@ -1,10 +1,10 @@
 #![cfg_attr(not(unix), allow(unused_imports))]
 
-pub mod hello_world {
-    tonic::include_proto!("helloworld");
+pub mod internal {
+    tonic::include_proto!("internal");
 }
 
-use hello_world::{greeter_client::GreeterClient, HelloRequest};
+use internal::{unix_client::UnixClient, AuthorizeRequest};
 #[cfg(unix)]
 use tokio::net::UnixStream;
 use tonic::transport::{Endpoint, Uri};
@@ -15,20 +15,19 @@ use tower::service_fn;
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let channel = Endpoint::try_from("http://[::]:50051")?
         .connect_with_connector(service_fn(|_: Uri| {
-            let path = "helloworld.sock";
-
             // Connect to a Uds socket
-            UnixStream::connect(path)
+            UnixStream::connect(libcommand::SOCK_FILE)
         }))
         .await?;
 
-    let mut client = GreeterClient::new(channel);
+    let mut client = UnixClient::new(channel);
 
-    let request = tonic::Request::new(HelloRequest {
-        name: "Tonic".into(),
+    let request = tonic::Request::new(AuthorizeRequest {
+        identifier: "Tonic".into(),
+        public_ssh_keys: "Tonic".into(),
     });
 
-    let response = client.say_hello(request).await?;
+    let response = client.authorize(request).await?;
 
     println!("RESPONSE={:?}", response);
 

src/daemon/main.rs

@@ -9,32 +9,52 @@ use tokio_stream::wrappers::UnixListenerStream;
 use tonic::transport::server::UdsConnectInfo;
 use tonic::{transport::Server, Request, Response, Status};
 
-pub mod hello_world {
-    tonic::include_proto!("helloworld");
+pub mod internal {
+    tonic::include_proto!("internal");
 }
 
-use hello_world::{
-    greeter_server::{Greeter, GreeterServer},
-    HelloReply, HelloRequest,
+use internal::{
+    unix_server::{Unix, UnixServer},
+    AuthorizeRequest, AuthorizeResponse, TerminateRequest, TerminateResponse
 };
 
 #[derive(Default)]
-pub struct MyGreeter {}
+pub struct DaemonServer {}
 
 #[tonic::async_trait]
-impl Greeter for MyGreeter {
-    async fn say_hello(
+impl Unix for DaemonServer {
+    async fn authorize(
         &self,
-        request: Request<HelloRequest>,
-    ) -> Result<Response<HelloReply>, Status> {
+        request: Request<AuthorizeRequest>,
+    ) -> Result<Response<AuthorizeResponse>, Status> {
         #[cfg(unix)]
         {
             let conn_info = request.extensions().get::<UdsConnectInfo>().unwrap();
             println!("Got a request {:?} with info {:?}", request, conn_info);
         }
 
-        let reply = hello_world::HelloReply {
-            message: format!("Hello {}!", request.into_inner().name),
+        let reply = internal::AuthorizeResponse {
+            status: internal::AuthorizationStatus::Authorized.into(),
+            error_message: "".into(),
+            log_file: "".into(),
+            session_uuid: "".into()
+        };
+        Ok(Response::new(reply))
+    }
+
+    async fn terminate(
+        &self,
+        request: Request<TerminateRequest>,
+    ) -> Result<Response<TerminateResponse>, Status> {
+        #[cfg(unix)]
+        {
+            let conn_info = request.extensions().get::<UdsConnectInfo>().unwrap();
+            println!("Got a request {:?} with info {:?}", request, conn_info);
+        }
+
+        let reply = internal::TerminateResponse {
+            status: internal::TerminateStatus::Ok.into(),
+            error_message: "".into(),
         };
         Ok(Response::new(reply))
     }
@@ -43,17 +63,15 @@ impl Greeter for MyGreeter {
 #[cfg(unix)]
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
-    let path = "helloworld.sock";
+    std::fs::create_dir_all(Path::new(libcommand::SOCK_FILE).parent().unwrap())?;
 
-    std::fs::create_dir_all(Path::new(path).parent().unwrap())?;
+    let server = DaemonServer::default();
 
-    let greeter = MyGreeter::default();
-
-    let uds = UnixListener::bind(path)?;
+    let uds = UnixListener::bind(libcommand::SOCK_FILE)?;
     let uds_stream = UnixListenerStream::new(uds);
 
     Server::builder()
-        .add_service(GreeterServer::new(greeter))
+        .add_service(UnixServer::new(server))
         .serve_with_incoming(uds_stream)
         .await?;
 

src/lib.rs

@@ -1 +1,8 @@
-pub(self) mod common;
+use serde::{Serialize, Deserialize};
+
+pub const SOCK_FILE : &'static str = "command_gateway.sock";
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Command {
+
+}