[opentitanproxy] move the proxy server out from opentitanlib

Signed-off-by: Gary Guo <[email protected]>

Author: nbdd0121

sw/host/opentitanlib/BUILD

@@ -122,11 +122,6 @@ rust_library(
         "src/ownership/mod.rs",
         "src/ownership/owner.rs",
         "src/ownership/rescue.rs",
-        "src/proxy/handler.rs",
-        "src/proxy/mod.rs",
-        "src/proxy/nonblocking_uart.rs",
-        "src/proxy/protocol.rs",
-        "src/proxy/socket_server.rs",
         "src/rescue/mod.rs",
         "src/rescue/serial.rs",
         "src/rescue/xmodem.rs",

sw/host/opentitanlib/src/lib.rs

@@ -17,7 +17,6 @@ pub mod image;
 pub mod io;
 pub mod otp;
 pub mod ownership;
-pub mod proxy;
 pub mod rescue;
 pub mod spiflash;
 pub mod test_utils;

sw/host/opentitansession/BUILD

@@ -11,6 +11,7 @@ rust_binary(
     srcs = ["src/main.rs"],
     deps = [
         "//sw/host/opentitanlib",
+        "//sw/host/ot_proxy/server",
         "@crate_index//:anyhow",
         "@crate_index//:clap",
         "@crate_index//:directories",

sw/host/opentitansession/src/main.rs

@@ -19,7 +19,7 @@ use std::str::FromStr;
 use std::time::Duration;
 
 use opentitanlib::backend;
-use opentitanlib::proxy::SessionHandler;
+use ot_proxy::SessionHandler;
 
 #[derive(Debug, Parser)]
 #[command(

sw/host/ot_proxy/proto/BUILD

@@ -0,0 +1,29 @@
+# Copyright lowRISC contributors (OpenTitan project).
+# Licensed under the Apache License, Version 2.0, see LICENSE for details.
+# SPDX-License-Identifier: Apache-2.0
+
+load("@rules_rust//rust:defs.bzl", "rust_doc", "rust_library", "rust_test")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "proto",
+    srcs = [
+        "src/lib.rs",
+    ],
+    crate_name = "ot_proxy_proto",
+    deps = [
+        "//sw/host/opentitanlib:opentitanlib_base",
+        "@crate_index//:serde",
+    ],
+)
+
+rust_doc(
+    name = "proto_doc",
+    crate = ":proto",
+)
+
+rust_test(
+    name = "proto_test",
+    crate = ":proto",
+)

sw/host/opentitanlib/src/proxy/protocol.rs renamed to sw/host/ot_proxy/proto/src/lib.rs

@@ -2,20 +2,21 @@
 // Licensed under the Apache License, Version 2.0, see LICENSE for details.
 // SPDX-License-Identifier: Apache-2.0
 
-use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
-use crate::bootstrap::BootstrapOptions;
-use crate::io::emu::{EmuState, EmuValue};
-use crate::io::gpio::{
+use serde::{Deserialize, Serialize};
+
+use opentitanlib::bootstrap::BootstrapOptions;
+use opentitanlib::io::emu::{EmuState, EmuValue};
+use opentitanlib::io::gpio::{
     ClockNature, MonitoringReadResponse, MonitoringStartResponse, PinMode, PullMode,
 };
-use crate::io::i2c::DeviceStatus;
-use crate::io::spi::{MaxSizes, TransferMode};
-use crate::io::uart::{FlowControl, Parity};
-use crate::transport::Capabilities;
-use crate::util::serializable_error::SerializedError;
-use crate::util::voltage::Voltage;
+use opentitanlib::io::i2c::DeviceStatus;
+use opentitanlib::io::spi::{MaxSizes, TransferMode};
+use opentitanlib::io::uart::{FlowControl, Parity};
+use opentitanlib::transport::Capabilities;
+use opentitanlib::util::serializable_error::SerializedError;
+use opentitanlib::util::voltage::Voltage;
 
 #[derive(Serialize, Deserialize)]
 pub enum Message {

sw/host/ot_proxy/server/BUILD

@@ -0,0 +1,40 @@
+# Copyright lowRISC contributors (OpenTitan project).
+# Licensed under the Apache License, Version 2.0, see LICENSE for details.
+# SPDX-License-Identifier: Apache-2.0
+
+load("@rules_rust//rust:defs.bzl", "rust_doc", "rust_library", "rust_test")
+
+package(default_visibility = ["//visibility:public"])
+
+rust_library(
+    name = "server",
+    srcs = [
+        "src/handler.rs",
+        "src/lib.rs",
+        "src/nonblocking_uart.rs",
+        "src/socket_server.rs",
+    ],
+    crate_name = "ot_proxy",
+    deps = [
+        "//sw/host/opentitanlib:opentitanlib_base",
+        "//sw/host/ot_proxy/proto",
+        "@crate_index//:anyhow",
+        "@crate_index//:clap",
+        "@crate_index//:log",
+        "@crate_index//:serde",
+        "@crate_index//:serde_json",
+        "@crate_index//:thiserror",
+        "@crate_index//:tokio",
+        "@crate_index//:typetag",
+    ],
+)
+
+rust_doc(
+    name = "server_doc",
+    crate = ":server",
+)
+
+rust_test(
+    name = "server_test",
+    crate = ":server",
+)

sw/host/opentitanlib/src/proxy/handler.rs renamed to sw/host/ot_proxy/server/src/handler.rs

@@ -10,24 +10,24 @@ use std::rc::Rc;
 use std::sync::{Arc, Mutex};
 use std::time::Duration;
 
-use super::CommandHandler;
-use super::protocol::{
+use opentitanlib::app::TransportWrapper;
+use opentitanlib::bootstrap::Bootstrap;
+use opentitanlib::io::gpio::{
+    BitbangEntry, DacBangEntry, GpioBitbangOperation, GpioDacBangOperation, GpioPin,
+};
+use opentitanlib::io::{i2c, spi};
+use opentitanlib::transport::TransportError;
+use opentitanlib::util::serializable_error::SerializedError;
+use ot_proxy_proto::{
     BitbangEntryRequest, BitbangEntryResponse, DacBangEntryRequest, EmuRequest, EmuResponse,
     GpioBitRequest, GpioBitResponse, GpioDacRequest, GpioDacResponse, GpioMonRequest,
     GpioMonResponse, GpioRequest, GpioResponse, I2cRequest, I2cResponse, I2cTransferRequest,
     I2cTransferResponse, Message, ProxyRequest, ProxyResponse, Request, Response, SpiRequest,
     SpiResponse, SpiTransferRequest, SpiTransferResponse, UartRequest, UartResponse,
 };
-use crate::app::TransportWrapper;
-use crate::bootstrap::Bootstrap;
-use crate::io::gpio::{
-    BitbangEntry, DacBangEntry, GpioBitbangOperation, GpioDacBangOperation, GpioPin,
-};
-use crate::io::{i2c, spi};
-use crate::proxy::Connection;
-use crate::proxy::nonblocking_uart::NonblockingUartRegistry;
-use crate::transport::TransportError;
-use crate::util::serializable_error::SerializedError;
+
+use super::nonblocking_uart::NonblockingUartRegistry;
+use super::{CommandHandler, Connection};
 
 /// Implementation of the handling of each protocol request, by means of an underlying
 /// `Transport` implementation.

sw/host/opentitanlib/src/proxy/mod.rs renamed to sw/host/ot_proxy/server/src/lib.rs

@@ -2,19 +2,20 @@
 // Licensed under the Apache License, Version 2.0, see LICENSE for details.
 // SPDX-License-Identifier: Apache-2.0
 
-use anyhow::{Result, bail};
-use handler::TransportCommandHandler;
-use protocol::Message;
-use socket_server::{Connection, JsonSocketServer};
 use std::net::SocketAddr;
 use std::sync::{Arc, Mutex};
+
+use anyhow::{Result, bail};
 use tokio::net::TcpListener;
 
-use crate::app::TransportWrapper;
+use opentitanlib::app::TransportWrapper;
+use ot_proxy_proto::Message;
+
+use handler::TransportCommandHandler;
+use socket_server::{Connection, JsonSocketServer};
 
 mod handler;
 mod nonblocking_uart;
-pub mod protocol;
 mod socket_server;
 
 /// Interface for handlers of protocol messages, responding to each message with a single
@@ -37,7 +38,7 @@ impl SessionHandler {
         // Find a suitable port to bind to.
         let socket = loop {
             let addr = SocketAddr::from(([0u8; 4], port));
-            match crate::util::runtime::block_on(async { TcpListener::bind(addr).await }) {
+            match opentitanlib::util::runtime::block_on(async { TcpListener::bind(addr).await }) {
                 Ok(socket) => break socket,
                 Err(e) if port >= limit => bail!(e),
                 Err(_) => port += 1,
@@ -56,7 +57,7 @@ impl SessionHandler {
     }
 
     pub fn run_loop(&mut self) -> Result<()> {
-        crate::util::runtime::block_on(crate::util::runtime::with_graceful_shutdown(
+        opentitanlib::util::runtime::block_on(opentitanlib::util::runtime::with_graceful_shutdown(
             self.socket_server.run_loop(),
         ))
     }

sw/host/opentitanlib/src/proxy/nonblocking_uart.rs renamed to sw/host/ot_proxy/server/src/nonblocking_uart.rs

@@ -2,16 +2,18 @@
 // Licensed under the Apache License, Version 2.0, see LICENSE for details.
 // SPDX-License-Identifier: Apache-2.0
 
-use anyhow::Result;
 use std::collections::HashMap;
 use std::collections::hash_map::Entry::{Occupied, Vacant};
 use std::hash::{Hash, Hasher};
 use std::ptr::hash;
 use std::rc::Rc;
 use std::sync::{Arc, Mutex, Weak};
 
+use anyhow::Result;
+
+use opentitanlib::io::uart::Uart;
+
 use super::socket_server::Connection;
-use crate::io::uart::Uart;
 
 pub struct NonblockingUartRegistry {
     // Set of Uart objects in "nonblocking read" mode.  Key is the address of the Uart object.
@@ -113,9 +115,9 @@ impl NonblockingUart {
             for conn in connections.into_iter() {
                 conn.lock()
                     .unwrap()
-                    .transmit_outgoing_msg(super::protocol::Message::Async {
+                    .transmit_outgoing_msg(ot_proxy_proto::Message::Async {
                         channel,
-                        msg: super::protocol::AsyncMessage::UartData {
+                        msg: ot_proxy_proto::AsyncMessage::UartData {
                             data: buf[0..len].to_vec(),
                         },
                     })?