[nexus] Add service manager to Nexus

common/src/address.rs

@@ -20,12 +20,12 @@ pub const SLED_PREFIX: u8 = 64;
 /// The amount of redundancy for DNS servers.
 ///
 /// Must be less than MAX_DNS_REDUNDANCY.
-pub const DNS_REDUNDANCY: usize = 1;
+pub const DNS_REDUNDANCY: u32 = 1;
 /// The maximum amount of redundancy for DNS servers.
 ///
 /// This determines the number of addresses which are
 /// reserved for DNS servers.
-pub const MAX_DNS_REDUNDANCY: usize = 5;
+pub const MAX_DNS_REDUNDANCY: u32 = 5;
 
 pub const DNS_PORT: u16 = 53;
 pub const DNS_SERVER_PORT: u16 = 5353;
@@ -34,10 +34,12 @@ pub const SLED_AGENT_PORT: u16 = 12345;
 /// The port propolis-server listens on inside the propolis zone.
 pub const PROPOLIS_PORT: u16 = 12400;
 pub const COCKROACH_PORT: u16 = 32221;
+pub const CRUCIBLE_PORT: u16 = 32345;
 pub const CLICKHOUSE_PORT: u16 = 8123;
 pub const OXIMETER_PORT: u16 = 12223;
 pub const DENDRITE_PORT: u16 = 12224;
 
+pub const NEXUS_EXTERNAL_PORT: u16 = 12220;
 pub const NEXUS_INTERNAL_PORT: u16 = 12221;
 
 // Anycast is a mechanism in which a single IP address is shared by multiple
@@ -180,7 +182,7 @@ mod test {
 
         // Observe the first DNS subnet within this reserved rack subnet.
         let dns_subnets = rack_subnet.get_dns_subnets();
-        assert_eq!(DNS_REDUNDANCY, dns_subnets.len());
+        assert_eq!(DNS_REDUNDANCY, dns_subnets.len() as u32);
 
         // The DNS address and GZ address should be only differing by one.
         assert_eq!(

common/src/sql/dbinit.sql

@@ -86,10 +86,11 @@ CREATE TABLE omicron.public.sled (
     last_used_address INET NOT NULL
 );
 
-/* Add an index which lets us look up sleds on a rack */
+/* Add an index which lets us look up the sleds on a rack */
 CREATE INDEX ON omicron.public.sled (
     rack_id
-) WHERE time_deleted IS NULL;
+) WHERE
+    time_deleted IS NULL;
 
 /*
  * Services
@@ -117,7 +118,13 @@ CREATE TABLE omicron.public.service (
 
 /* Add an index which lets us look up the services on a sled */
 CREATE INDEX ON omicron.public.service (
-    sled_id
+    sled_id,
+    kind
+);
+
+/* Add an index which lets us look up services of a particular kind on a sled */
+CREATE INDEX ON omicron.public.service (
+    kind
 );
 
 /*
@@ -140,6 +147,11 @@ CREATE TABLE omicron.public.Zpool (
     total_size INT NOT NULL
 );
 
+/* Create an index which allows looking up all zpools on a sled */
+CREATE INDEX on omicron.public.Zpool (
+    sled_id
+) WHERE time_deleted IS NULL;
+
 CREATE TYPE omicron.public.dataset_kind AS ENUM (
   'crucible',
   'cockroach',
@@ -170,6 +182,11 @@ CREATE TABLE omicron.public.Dataset (
     size_used INT
 );
 
+/* Create an index which allows looking up all datasets in a pool */
+CREATE INDEX on omicron.public.Dataset (
+    pool_id
+) WHERE time_deleted IS NULL;
+
 /* Create an index on the size usage for Crucible's allocation */
 CREATE INDEX on omicron.public.Dataset (
     size_used

nexus/db-model/Cargo.toml

@@ -9,6 +9,7 @@ anyhow = "1.0"
 chrono = { version = "0.4", features = ["serde"] }
 diesel = { version = "2.0.0-rc.1", features = ["postgres", "r2d2", "chrono", "serde_json", "network-address", "uuid"] }
 hex = "0.4.3"
+internal-dns-client = { path = "../../internal-dns-client" }
 ipnetwork = "0.20"
 macaddr = { version = "1.0.1", features = [ "serde_std" ]}
 newtype_derive = "0.1.6"

nexus/db-model/src/dataset.rs

@@ -4,11 +4,14 @@
 
 use super::{DatasetKind, Generation, Region, SqlU16};
 use crate::collection::DatastoreCollectionConfig;
+use crate::ipv6;
 use crate::schema::{dataset, region};
 use chrono::{DateTime, Utc};
 use db_macros::Asset;
+use internal_dns_client::names::{BackendName, ServiceName, AAAA, SRV};
+use nexus_types::identity::Asset;
 use serde::{Deserialize, Serialize};
-use std::net::SocketAddr;
+use std::net::{Ipv6Addr, SocketAddrV6};
 use uuid::Uuid;
 
 /// Database representation of a Dataset.
@@ -35,18 +38,18 @@ pub struct Dataset {
 
     pub pool_id: Uuid,
 
-    ip: ipnetwork::IpNetwork,
+    ip: ipv6::Ipv6Addr,
     port: SqlU16,
 
-    kind: DatasetKind,
+    pub kind: DatasetKind,
     pub size_used: Option<i64>,
 }
 
 impl Dataset {
     pub fn new(
         id: Uuid,
         pool_id: Uuid,
-        addr: SocketAddr,
+        addr: SocketAddrV6,
         kind: DatasetKind,
     ) -> Self {
         let size_used = match kind {
@@ -65,12 +68,26 @@ impl Dataset {
         }
     }
 
-    pub fn address(&self) -> SocketAddr {
+    pub fn address(&self) -> SocketAddrV6 {
         self.address_with_port(self.port.into())
     }
 
-    pub fn address_with_port(&self, port: u16) -> SocketAddr {
-        SocketAddr::new(self.ip.ip(), port)
+    pub fn address_with_port(&self, port: u16) -> SocketAddrV6 {
+        SocketAddrV6::new(Ipv6Addr::from(self.ip), port, 0, 0)
+    }
+
+    pub fn aaaa(&self) -> AAAA {
+        AAAA::Zone(self.id())
+    }
+
+    pub fn srv(&self) -> SRV {
+        match self.kind {
+            DatasetKind::Crucible => {
+                SRV::Backend(BackendName::Crucible, self.id())
+            }
+            DatasetKind::Clickhouse => SRV::Service(ServiceName::Clickhouse),
+            DatasetKind::Cockroach => SRV::Service(ServiceName::Cockroach),
+        }
     }
 }
 

nexus/db-model/src/dataset_kind.rs

@@ -4,14 +4,15 @@
 
 use super::impl_enum_type;
 use nexus_types::internal_api;
+use omicron_common::address::{CLICKHOUSE_PORT, COCKROACH_PORT, CRUCIBLE_PORT};
 use serde::{Deserialize, Serialize};
 
 impl_enum_type!(
-    #[derive(SqlType, Debug, QueryId)]
+    #[derive(Clone, SqlType, Debug, QueryId)]
     #[diesel(postgres_type(name = "dataset_kind"))]
     pub struct DatasetKindEnum;
 
-    #[derive(Clone, Debug, AsExpression, FromSqlRow, Serialize, Deserialize, PartialEq)]
+    #[derive(Clone, Copy, Debug, AsExpression, FromSqlRow, Serialize, Deserialize, PartialEq)]
     #[diesel(sql_type = DatasetKindEnum)]
     pub enum DatasetKind;
 
@@ -21,6 +22,16 @@ impl_enum_type!(
     Clickhouse => b"clickhouse"
 );
 
+impl DatasetKind {
+    pub fn port(&self) -> u16 {
+        match self {
+            DatasetKind::Crucible => CRUCIBLE_PORT,
+            DatasetKind::Cockroach => COCKROACH_PORT,
+            DatasetKind::Clickhouse => CLICKHOUSE_PORT,
+        }
+    }
+}
+
 impl From<internal_api::params::DatasetKind> for DatasetKind {
     fn from(k: internal_api::params::DatasetKind) -> Self {
         match k {

nexus/db-model/src/ipv6.rs

@@ -16,9 +16,19 @@ use diesel::sql_types::Inet;
 use ipnetwork::IpNetwork;
 use ipnetwork::Ipv6Network;
 use omicron_common::api::external::Error;
+use serde::{Deserialize, Serialize};
 
 #[derive(
-    Clone, Copy, AsExpression, FromSqlRow, PartialEq, Ord, PartialOrd, Eq,
+    Clone,
+    Copy,
+    AsExpression,
+    FromSqlRow,
+    PartialEq,
+    Ord,
+    PartialOrd,
+    Eq,
+    Deserialize,
+    Serialize,
 )]
 #[diesel(sql_type = Inet)]
 pub struct Ipv6Addr(std::net::Ipv6Addr);

nexus/db-model/src/service.rs

@@ -6,11 +6,16 @@ use super::ServiceKind;
 use crate::ipv6;
 use crate::schema::service;
 use db_macros::Asset;
-use std::net::Ipv6Addr;
+use internal_dns_client::names::{ServiceName, AAAA, SRV};
+use nexus_types::identity::Asset;
+use omicron_common::address::{
+    DENDRITE_PORT, DNS_SERVER_PORT, NEXUS_INTERNAL_PORT, OXIMETER_PORT,
+};
+use std::net::{Ipv6Addr, SocketAddrV6};
 use uuid::Uuid;
 
 /// Representation of services which may run on Sleds.
-#[derive(Queryable, Insertable, Debug, Clone, Selectable, Asset)]
+#[derive(Queryable, Insertable, Debug, Clone, Selectable, Asset, PartialEq)]
 #[diesel(table_name = service)]
 pub struct Service {
     #[diesel(embed)]
@@ -35,4 +40,27 @@ impl Service {
             kind,
         }
     }
+
+    pub fn aaaa(&self) -> AAAA {
+        AAAA::Zone(self.id())
+    }
+
+    pub fn srv(&self) -> SRV {
+        match self.kind {
+            ServiceKind::InternalDNS => SRV::Service(ServiceName::InternalDNS),
+            ServiceKind::Nexus => SRV::Service(ServiceName::Nexus),
+            ServiceKind::Oximeter => SRV::Service(ServiceName::Oximeter),
+            ServiceKind::Dendrite => SRV::Service(ServiceName::Dendrite),
+        }
+    }
+
+    pub fn address(&self) -> SocketAddrV6 {
+        let port = match self.kind {
+            ServiceKind::InternalDNS => DNS_SERVER_PORT,
+            ServiceKind::Nexus => NEXUS_INTERNAL_PORT,
+            ServiceKind::Oximeter => OXIMETER_PORT,
+            ServiceKind::Dendrite => DENDRITE_PORT,
+        };
+        SocketAddrV6::new(Ipv6Addr::from(self.ip), port, 0, 0)
+    }
 }

nexus/db-model/src/service_kind.rs

@@ -7,11 +7,11 @@ use nexus_types::internal_api;
 use serde::{Deserialize, Serialize};
 
 impl_enum_type!(
-    #[derive(SqlType, Debug, QueryId)]
+    #[derive(Clone, SqlType, Debug, QueryId)]
     #[diesel(postgres_type(name = "service_kind"))]
     pub struct ServiceKindEnum;
 
-    #[derive(Clone, Debug, AsExpression, FromSqlRow, Serialize, Deserialize, PartialEq)]
+    #[derive(Clone, Copy, Debug, AsExpression, FromSqlRow, Serialize, Deserialize, PartialEq)]
     #[diesel(sql_type = ServiceKindEnum)]
     pub enum ServiceKind;
 

nexus/db-model/src/sled.rs

@@ -14,7 +14,7 @@ use std::net::SocketAddrV6;
 use uuid::Uuid;
 
 /// Database representation of a Sled.
-#[derive(Queryable, Insertable, Debug, Clone, Selectable, Asset)]
+#[derive(Queryable, Insertable, Debug, Clone, Selectable, Asset, PartialEq)]
 #[diesel(table_name = sled)]
 pub struct Sled {
     #[diesel(embed)]

nexus/db-model/src/zpool.rs

@@ -14,7 +14,7 @@ use uuid::Uuid;
 ///
 /// A zpool represents a ZFS storage pool, allocated on a single
 /// physical sled.
-#[derive(Queryable, Insertable, Debug, Clone, Selectable, Asset)]
+#[derive(Queryable, Insertable, Debug, Clone, Selectable, Asset, PartialEq)]
 #[diesel(table_name = zpool)]
 pub struct Zpool {
     #[diesel(embed)]