Move and library crates into a dedicated directory and rename them

safekeeper/Cargo.toml

@@ -33,9 +33,9 @@ tokio-util = { version = "0.7", features = ["io"] }
 rusoto_core = "0.47"
 rusoto_s3 = "0.47"
 
-postgres_ffi = { path = "../postgres_ffi" }
-zenith_metrics = { path = "../zenith_metrics" }
-zenith_utils = { path = "../zenith_utils" }
+postgres_ffi = { path = "../libs/postgres_ffi" }
+metrics = { path = "../libs/metrics" }
+utils = { path = "../libs/utils" }
 workspace_hack = { version = "0.1", path = "../workspace_hack" }
 
 [dev-dependencies]

safekeeper/src/bin/safekeeper.rs

@@ -10,11 +10,9 @@ use std::fs::{self, File};
 use std::io::{ErrorKind, Write};
 use std::path::{Path, PathBuf};
 use std::thread;
+use tokio::sync::mpsc;
 use tracing::*;
 use url::{ParseError, Url};
-use zenith_utils::http::endpoint;
-use zenith_utils::zid::ZNodeId;
-use zenith_utils::{logging, tcp_listener, GIT_VERSION};
 
 use safekeeper::control_file::{self};
 use safekeeper::defaults::{DEFAULT_HTTP_LISTEN_ADDR, DEFAULT_PG_LISTEN_ADDR};
@@ -23,15 +21,15 @@ use safekeeper::s3_offload;
 use safekeeper::wal_service;
 use safekeeper::SafeKeeperConf;
 use safekeeper::{broker, callmemaybe};
-use tokio::sync::mpsc;
-use zenith_utils::shutdown::exit_now;
-use zenith_utils::signals;
+use utils::{
+    http::endpoint, logging, shutdown::exit_now, signals, tcp_listener, zid::ZNodeId, GIT_VERSION,
+};
 
 const LOCK_FILE_NAME: &str = "safekeeper.lock";
 const ID_FILE_NAME: &str = "safekeeper.id";
 
 fn main() -> Result<()> {
-    zenith_metrics::set_common_metrics_prefix("safekeeper");
+    metrics::set_common_metrics_prefix("safekeeper");
     let arg_matches = App::new("Zenith safekeeper")
         .about("Store WAL stream to local file system and push it to WAL receivers")
         .version(GIT_VERSION)

safekeeper/src/broker.rs

@@ -17,14 +17,12 @@ use std::time::Duration;
 use tokio::task::JoinHandle;
 use tokio::{runtime, time::sleep};
 use tracing::*;
-use zenith_utils::zid::ZTenantId;
-use zenith_utils::zid::ZTimelineId;
-use zenith_utils::{
-    lsn::Lsn,
-    zid::{ZNodeId, ZTenantTimelineId},
-};
 
 use crate::{safekeeper::Term, timeline::GlobalTimelines, SafeKeeperConf};
+use utils::{
+    lsn::Lsn,
+    zid::{ZNodeId, ZTenantId, ZTenantTimelineId, ZTimelineId},
+};
 
 const RETRY_INTERVAL_MSEC: u64 = 1000;
 const PUSH_INTERVAL_MSEC: u64 = 1000;

safekeeper/src/callmemaybe.rs

@@ -16,8 +16,10 @@ use tokio::sync::mpsc::UnboundedReceiver;
 use tokio::task;
 use tokio_postgres::NoTls;
 use tracing::*;
-use zenith_utils::connstring::connection_host_port;
-use zenith_utils::zid::{ZTenantId, ZTimelineId};
+use utils::{
+    connstring::connection_host_port,
+    zid::{ZTenantId, ZTimelineId},
+};
 
 async fn request_callback(
     pageserver_connstr: String,

safekeeper/src/control_file.rs

@@ -10,13 +10,11 @@ use std::ops::Deref;
 use std::path::{Path, PathBuf};
 
 use tracing::*;
-use zenith_metrics::{register_histogram_vec, Histogram, HistogramVec, DISK_WRITE_SECONDS_BUCKETS};
-use zenith_utils::bin_ser::LeSer;
-
-use zenith_utils::zid::ZTenantTimelineId;
 
 use crate::control_file_upgrade::upgrade_control_file;
 use crate::safekeeper::{SafeKeeperState, SK_FORMAT_VERSION, SK_MAGIC};
+use metrics::{register_histogram_vec, Histogram, HistogramVec, DISK_WRITE_SECONDS_BUCKETS};
+use utils::{bin_ser::LeSer, zid::ZTenantTimelineId};
 
 use crate::SafeKeeperConf;
 
@@ -251,10 +249,10 @@ impl Storage for FileStorage {
 mod test {
     use super::FileStorage;
     use super::*;
-    use crate::{safekeeper::SafeKeeperState, SafeKeeperConf, ZTenantTimelineId};
+    use crate::{safekeeper::SafeKeeperState, SafeKeeperConf};
     use anyhow::Result;
     use std::fs;
-    use zenith_utils::lsn::Lsn;
+    use utils::{lsn::Lsn, zid::ZTenantTimelineId};
 
     fn stub_conf() -> SafeKeeperConf {
         let workdir = tempfile::tempdir().unwrap().into_path();

safekeeper/src/control_file_upgrade.rs

@@ -5,7 +5,7 @@ use crate::safekeeper::{
 use anyhow::{bail, Result};
 use serde::{Deserialize, Serialize};
 use tracing::*;
-use zenith_utils::{
+use utils::{
     bin_ser::LeSer,
     lsn::Lsn,
     pq_proto::SystemId,

safekeeper/src/handler.rs

@@ -14,11 +14,12 @@ use regex::Regex;
 use std::str::FromStr;
 use std::sync::Arc;
 use tracing::info;
-use zenith_utils::lsn::Lsn;
-use zenith_utils::postgres_backend;
-use zenith_utils::postgres_backend::PostgresBackend;
-use zenith_utils::pq_proto::{BeMessage, FeStartupPacket, RowDescriptor, INT4_OID, TEXT_OID};
-use zenith_utils::zid::{ZTenantId, ZTenantTimelineId, ZTimelineId};
+use utils::{
+    lsn::Lsn,
+    postgres_backend::{self, PostgresBackend},
+    pq_proto::{BeMessage, FeStartupPacket, RowDescriptor, INT4_OID, TEXT_OID},
+    zid::{ZTenantId, ZTenantTimelineId, ZTimelineId},
+};
 
 use crate::callmemaybe::CallmeEvent;
 use tokio::sync::mpsc::UnboundedSender;

safekeeper/src/http/models.rs

@@ -1,5 +1,5 @@
 use serde::{Deserialize, Serialize};
-use zenith_utils::zid::{ZNodeId, ZTenantId, ZTimelineId};
+use utils::zid::{ZNodeId, ZTenantId, ZTimelineId};
 
 #[derive(Serialize, Deserialize)]
 pub struct TimelineCreateRequest {

safekeeper/src/http/routes.rs

@@ -4,21 +4,22 @@ use serde::Serialize;
 use serde::Serializer;
 use std::fmt::Display;
 use std::sync::Arc;
-use zenith_utils::http::json::json_request;
-use zenith_utils::http::{RequestExt, RouterBuilder};
-use zenith_utils::lsn::Lsn;
-use zenith_utils::zid::ZNodeId;
-use zenith_utils::zid::ZTenantTimelineId;
 
 use crate::safekeeper::Term;
 use crate::safekeeper::TermHistory;
 use crate::timeline::GlobalTimelines;
 use crate::SafeKeeperConf;
-use zenith_utils::http::endpoint;
-use zenith_utils::http::error::ApiError;
-use zenith_utils::http::json::json_response;
-use zenith_utils::http::request::parse_request_param;
-use zenith_utils::zid::{ZTenantId, ZTimelineId};
+use utils::{
+    http::{
+        endpoint,
+        error::ApiError,
+        json::{json_request, json_response},
+        request::parse_request_param,
+        RequestExt, RouterBuilder,
+    },
+    lsn::Lsn,
+    zid::{ZNodeId, ZTenantId, ZTenantTimelineId, ZTimelineId},
+};
 
 use super::models::TimelineCreateRequest;
 

safekeeper/src/json_ctrl.rs

@@ -22,9 +22,11 @@ use crate::timeline::TimelineTools;
 use postgres_ffi::pg_constants;
 use postgres_ffi::xlog_utils;
 use postgres_ffi::{uint32, uint64, Oid, XLogRecord};
-use zenith_utils::lsn::Lsn;
-use zenith_utils::postgres_backend::PostgresBackend;
-use zenith_utils::pq_proto::{BeMessage, RowDescriptor, TEXT_OID};
+use utils::{
+    lsn::Lsn,
+    postgres_backend::PostgresBackend,
+    pq_proto::{BeMessage, RowDescriptor, TEXT_OID},
+};
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct AppendLogicalMessage {
@@ -191,7 +193,7 @@ struct XlLogicalMessage {
 
 impl XlLogicalMessage {
     pub fn encode(&self) -> Bytes {
-        use zenith_utils::bin_ser::LeSer;
+        use utils::bin_ser::LeSer;
         self.ser().unwrap().into()
     }
 }

safekeeper/src/lib.rs

@@ -3,7 +3,7 @@ use std::path::PathBuf;
 use std::time::Duration;
 use url::Url;
 
-use zenith_utils::zid::{ZNodeId, ZTenantTimelineId};
+use utils::zid::{ZNodeId, ZTenantTimelineId};
 
 pub mod broker;
 pub mod callmemaybe;

safekeeper/src/receive_wal.rs

@@ -7,7 +7,6 @@ use anyhow::{anyhow, bail, Result};
 use bytes::BytesMut;
 use tokio::sync::mpsc::UnboundedSender;
 use tracing::*;
-use zenith_utils::sock_split::ReadStream;
 
 use crate::timeline::Timeline;
 
@@ -23,8 +22,11 @@ use crate::safekeeper::ProposerAcceptorMessage;
 
 use crate::handler::SafekeeperPostgresHandler;
 use crate::timeline::TimelineTools;
-use zenith_utils::postgres_backend::PostgresBackend;
-use zenith_utils::pq_proto::{BeMessage, FeMessage};
+use utils::{
+    postgres_backend::PostgresBackend,
+    pq_proto::{BeMessage, FeMessage},
+    sock_split::ReadStream,
+};
 
 use crate::callmemaybe::CallmeEvent;
 

safekeeper/src/safekeeper.rs

@@ -11,8 +11,6 @@ use std::cmp::min;
 use std::fmt;
 use std::io::Read;
 use tracing::*;
-use zenith_utils::zid::ZNodeId;
-use zenith_utils::zid::ZTenantTimelineId;
 
 use lazy_static::lazy_static;
 
@@ -20,13 +18,14 @@ use crate::broker::SafekeeperInfo;
 use crate::control_file;
 use crate::send_wal::HotStandbyFeedback;
 use crate::wal_storage;
+use metrics::{register_gauge_vec, Gauge, GaugeVec};
 use postgres_ffi::xlog_utils::MAX_SEND_SIZE;
-use zenith_metrics::{register_gauge_vec, Gauge, GaugeVec};
-use zenith_utils::bin_ser::LeSer;
-use zenith_utils::lsn::Lsn;
-use zenith_utils::pq_proto::SystemId;
-use zenith_utils::pq_proto::ZenithFeedback;
-use zenith_utils::zid::{ZTenantId, ZTimelineId};
+use utils::{
+    bin_ser::LeSer,
+    lsn::Lsn,
+    pq_proto::{SystemId, ZenithFeedback},
+    zid::{ZNodeId, ZTenantId, ZTenantTimelineId, ZTimelineId},
+};
 
 pub const SK_MAGIC: u32 = 0xcafeceefu32;
 pub const SK_FORMAT_VERSION: u32 = 4;

safekeeper/src/send_wal.rs

@@ -19,13 +19,14 @@ use std::time::Duration;
 use std::{str, thread};
 use tokio::sync::mpsc::UnboundedSender;
 use tracing::*;
-use zenith_utils::bin_ser::BeSer;
-use zenith_utils::lsn::Lsn;
-use zenith_utils::postgres_backend::PostgresBackend;
-use zenith_utils::pq_proto::{BeMessage, FeMessage, WalSndKeepAlive, XLogDataBody, ZenithFeedback};
-use zenith_utils::sock_split::ReadStream;
-
-use zenith_utils::zid::{ZTenantId, ZTimelineId};
+use utils::{
+    bin_ser::BeSer,
+    lsn::Lsn,
+    postgres_backend::PostgresBackend,
+    pq_proto::{BeMessage, FeMessage, WalSndKeepAlive, XLogDataBody, ZenithFeedback},
+    sock_split::ReadStream,
+    zid::{ZTenantId, ZTimelineId},
+};
 
 // See: https://www.postgresql.org/docs/13/protocol-replication.html
 const HOT_STANDBY_FEEDBACK_TAG_BYTE: u8 = b'h';

safekeeper/src/timeline.rs

@@ -14,8 +14,11 @@ use std::time::Duration;
 use tokio::sync::mpsc::UnboundedSender;
 use tracing::*;
 
-use zenith_utils::lsn::Lsn;
-use zenith_utils::zid::{ZNodeId, ZTenantTimelineId};
+use utils::{
+    lsn::Lsn,
+    pq_proto::ZenithFeedback,
+    zid::{ZNodeId, ZTenantTimelineId},
+};
 
 use crate::broker::SafekeeperInfo;
 use crate::callmemaybe::{CallmeEvent, SubscriptionStateKey};
@@ -30,8 +33,6 @@ use crate::wal_storage;
 use crate::wal_storage::Storage as wal_storage_iface;
 use crate::SafeKeeperConf;
 
-use zenith_utils::pq_proto::ZenithFeedback;
-
 const POLL_STATE_TIMEOUT: Duration = Duration::from_secs(1);
 
 /// Replica status update + hot standby feedback

safekeeper/src/wal_service.rs

@@ -12,7 +12,7 @@ use crate::callmemaybe::CallmeEvent;
 use crate::handler::SafekeeperPostgresHandler;
 use crate::SafeKeeperConf;
 use tokio::sync::mpsc::UnboundedSender;
-use zenith_utils::postgres_backend::{AuthType, PostgresBackend};
+use utils::postgres_backend::{AuthType, PostgresBackend};
 
 /// Accept incoming TCP connections and spawn them into a background thread.
 pub fn thread_main(

safekeeper/src/wal_storage.rs

@@ -20,8 +20,7 @@ use std::path::{Path, PathBuf};
 
 use tracing::*;
 
-use zenith_utils::lsn::Lsn;
-use zenith_utils::zid::ZTenantTimelineId;
+use utils::{lsn::Lsn, zid::ZTenantTimelineId};
 
 use crate::safekeeper::SafeKeeperState;
 
@@ -30,7 +29,7 @@ use postgres_ffi::xlog_utils::{XLogFileName, XLOG_BLCKSZ};
 
 use postgres_ffi::waldecoder::WalStreamDecoder;
 
-use zenith_metrics::{
+use metrics::{
     register_gauge_vec, register_histogram_vec, Gauge, GaugeVec, Histogram, HistogramVec,
     DISK_WRITE_SECONDS_BUCKETS,
 };