Skip to content

Commit

Permalink
fix(group): require > 1 use count on invites
Browse files Browse the repository at this point in the history
  • Loading branch information
@NathanFlurry
NathanFlurry committed Jul 7, 2024
1 parent 796a5e6 commit f25cffb
Show file tree
Hide file tree
Showing 64 changed files with 1,802 additions and 2,191 deletions.
2 changes: 1 addition & 1 deletion fern/definition/servers/common.yml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -48,7 +48,7 @@ types:
properties:
routing: PortRouting
server_port: optional<integer>
public_host: optional<string>
public_hostname: optional<string>
public_port: optional<integer>

PortRouting:
Expand Down
12 changes: 12 additions & 0 deletions fern/definition/servers/servers.yml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,15 @@ service:
auth: true
base-path: /servers/servers
endpoints:
get:
path: "/{server_id}"
method: GET
docs: Gets a dynamic server.
path-parameters:
server_id:
docs: The id of the server to destroy
type: uuid
response: GetServerResponse
create:
path: ""
method: POST
Expand Down Expand Up @@ -34,6 +43,9 @@ service:
response: DestroyServerResponse

types:
GetServerResponse:
properties:
servers: list<commons.Server>
CreateServerRequest:
properties:
datacenter:
Expand Down
253 changes: 85 additions & 168 deletions lib/convert/src/impls/ds.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -7,13 +7,9 @@ use rivet_operation::prelude::*;
use crate::{ApiFrom, ApiInto, ApiTryFrom, ApiTryInto};
use serde_json::to_value;

impl ApiTryFrom<backend::dynamic_servers::Server> for models::ServersServer {
impl ApiTryFrom<backend::ds::Server> for models::ServersServer {
type Error = GlobalError;
fn api_try_from(
value: backend::dynamic_servers::Server,
) -> GlobalResult<models::ServersServer> {
let backend::dynamic_servers::server::Runtime::DockerRuntime(docker_runtime) =
unwrap!(value.runtime);
fn api_try_from(value: backend::ds::Server) -> GlobalResult<models::ServersServer> {
Ok(models::ServersServer {
cluster_id: unwrap!(value.cluster_id).as_uuid(),
create_ts: value.create_ts,
Expand All @@ -24,264 +20,185 @@ impl ApiTryFrom<backend::dynamic_servers::Server> for models::ServersServer {
metadata: Some(to_value(value.metadata).unwrap()),
resources: Box::new(unwrap!(value.resources).api_into()),
server_id: unwrap!(value.server_id).as_uuid(),
args: Some(docker_runtime.args),
environment: Some(docker_runtime.environment),
image_id: unwrap!(docker_runtime.image_id).as_uuid(),
network: Box::new(unwrap!(docker_runtime.network).api_try_into()?),
args: Some(value.args),
environment: Some(value.environment),
image_id: unwrap!(value.image_id).as_uuid(),
network: Box::new(models::ServersNetwork {
mode: Some(
unwrap!(backend::ds::NetworkMode::from_i32(value.network_mode)).api_into(),
),
ports: value
.network_ports
.into_iter()
.map(|(s, p)| Ok((s, p.api_try_into()?)))
.collect::<GlobalResult<HashMap<_, _>>>()?,
}),
})
}
}

impl ApiFrom<models::ServersResources> for backend::dynamic_servers::ServerResources {
fn api_from(value: models::ServersResources) -> backend::dynamic_servers::ServerResources {
backend::dynamic_servers::ServerResources {
impl ApiFrom<models::ServersResources> for backend::ds::ServerResources {
fn api_from(value: models::ServersResources) -> backend::ds::ServerResources {
backend::ds::ServerResources {
cpu_millicores: value.cpu,
memory_mib: value.memory,
}
}
}

impl ApiFrom<backend::dynamic_servers::ServerResources> for models::ServersResources {
fn api_from(value: backend::dynamic_servers::ServerResources) -> models::ServersResources {
impl ApiFrom<backend::ds::ServerResources> for models::ServersResources {
fn api_from(value: backend::ds::ServerResources) -> models::ServersResources {
models::ServersResources {
cpu: value.cpu_millicores,
memory: value.memory_mib,
}
}
}

impl ApiTryInto<models::ServersNetwork> for backend::dynamic_servers::DockerNetwork {
type Error = GlobalError;

fn api_try_into(self) -> GlobalResult<models::ServersNetwork> {
Ok(models::ServersNetwork {
mode: Some(
unwrap!(backend::dynamic_servers::DockerNetworkMode::from_i32(
self.mode
))
.api_into(),
),
ports: self
.ports
.into_iter()
.map(|(s, p)| Ok((s, p.api_try_into()?)))
.collect::<GlobalResult<HashMap<_, _>>>()?,
})
}
}

impl ApiFrom<models::ServersNetworkMode> for backend::dynamic_servers::DockerNetworkMode {
fn api_from(value: models::ServersNetworkMode) -> backend::dynamic_servers::DockerNetworkMode {
impl ApiFrom<models::ServersNetworkMode> for backend::ds::NetworkMode {
fn api_from(value: models::ServersNetworkMode) -> backend::ds::NetworkMode {
match value {
models::ServersNetworkMode::Bridge => {
backend::dynamic_servers::DockerNetworkMode::Bridge
}
models::ServersNetworkMode::Host => backend::dynamic_servers::DockerNetworkMode::Host,
models::ServersNetworkMode::Bridge => backend::ds::NetworkMode::Bridge,
models::ServersNetworkMode::Host => backend::ds::NetworkMode::Host,
}
}
}

impl ApiFrom<backend::dynamic_servers::DockerNetworkMode> for models::ServersNetworkMode {
fn api_from(value: backend::dynamic_servers::DockerNetworkMode) -> models::ServersNetworkMode {
impl ApiFrom<backend::ds::NetworkMode> for models::ServersNetworkMode {
fn api_from(value: backend::ds::NetworkMode) -> models::ServersNetworkMode {
match value {
backend::dynamic_servers::DockerNetworkMode::Bridge => {
models::ServersNetworkMode::Bridge
}
backend::dynamic_servers::DockerNetworkMode::Host => models::ServersNetworkMode::Host,
backend::ds::NetworkMode::Bridge => models::ServersNetworkMode::Bridge,
backend::ds::NetworkMode::Host => models::ServersNetworkMode::Host,
}
}
}

impl ApiTryFrom<models::ServersPort> for backend::dynamic_servers::DockerPort {
type Error = GlobalError;

fn api_try_from(
value: models::ServersPort,
) -> GlobalResult<backend::dynamic_servers::DockerPort> {
Ok(backend::dynamic_servers::DockerPort {
port: value.server_port,
routing: Some((*value.routing).api_try_into()?),
})
}
}

impl ApiTryFrom<backend::dynamic_servers::DockerPort> for models::ServersPort {
impl ApiTryFrom<backend::ds::Port> for models::ServersPort {
type Error = GlobalError;

fn api_try_from(
value: backend::dynamic_servers::DockerPort,
) -> GlobalResult<models::ServersPort> {
fn api_try_from(value: backend::ds::Port) -> GlobalResult<models::ServersPort> {
Ok(models::ServersPort {
server_port: value.port,
server_port: value.server_port,
routing: Box::new(unwrap!(value.routing).api_try_into()?),
public_host: None,
public_port: None,
public_hostname: value.public_hostname,
public_port: value.public_port,
})
}
}

impl ApiTryFrom<models::ServersPortRouting> for backend::dynamic_servers::docker_port::Routing {
impl ApiTryFrom<models::ServersPortRouting> for backend::ds::port::Routing {
type Error = GlobalError;

fn api_try_from(
value: models::ServersPortRouting,
) -> GlobalResult<backend::dynamic_servers::docker_port::Routing> {
fn api_try_from(value: models::ServersPortRouting) -> GlobalResult<backend::ds::port::Routing> {
match (value.game_guard, value.host) {
(Some(game_guard), None) => Ok(
backend::dynamic_servers::docker_port::Routing::GameGuard((*game_guard).api_into()),
),
(None, Some(host)) => Ok(backend::dynamic_servers::docker_port::Routing::Host(
(*host).api_into(),
(Some(game_guard), None) => Ok(backend::ds::port::Routing::GameGuard(
(*game_guard).api_into(),
)),
(None, Some(host)) => Ok(backend::ds::port::Routing::Host((*host).api_into())),
(None, None) => bail_with!(SERVERS_NO_PORT_ROUTERS),
_ => bail_with!(SERVERS_MULTIPLE_PORT_ROUTERS),
}
}
}

impl ApiTryFrom<backend::dynamic_servers::docker_port::Routing> for models::ServersPortRouting {
impl ApiTryFrom<backend::ds::port::Routing> for models::ServersPortRouting {
type Error = GlobalError;

fn api_try_from(
value: backend::dynamic_servers::docker_port::Routing,
) -> GlobalResult<models::ServersPortRouting> {
fn api_try_from(value: backend::ds::port::Routing) -> GlobalResult<models::ServersPortRouting> {
match value {
backend::dynamic_servers::docker_port::Routing::GameGuard(game_guard) => {
Ok(models::ServersPortRouting {
game_guard: Some(Box::new(game_guard.api_try_into()?)),
host: None,
})
}
backend::dynamic_servers::docker_port::Routing::Host(host) => {
Ok(models::ServersPortRouting {
game_guard: None,
host: Some(Box::new(host.api_try_into()?)),
})
}
backend::ds::port::Routing::GameGuard(game_guard) => Ok(models::ServersPortRouting {
game_guard: Some(Box::new(game_guard.api_try_into()?)),
host: None,
}),
backend::ds::port::Routing::Host(host) => Ok(models::ServersPortRouting {
game_guard: None,
host: Some(Box::new(host.api_try_into()?)),
}),
}
}
}

impl ApiFrom<models::ServersGameGuardRouting> for backend::dynamic_servers::DockerGameGuardRouting {
fn api_from(
value: models::ServersGameGuardRouting,
) -> backend::dynamic_servers::DockerGameGuardRouting {
backend::dynamic_servers::DockerGameGuardRouting {
protocol: backend::dynamic_servers::GameGuardProtocol::api_from(
impl ApiFrom<models::ServersGameGuardRouting> for backend::ds::GameGuardRouting {
fn api_from(value: models::ServersGameGuardRouting) -> backend::ds::GameGuardRouting {
backend::ds::GameGuardRouting {
protocol: backend::ds::GameGuardProtocol::api_from(
value.protocol.unwrap_or_default().into(),
) as i32,
}
}
}

impl ApiTryFrom<backend::dynamic_servers::DockerGameGuardRouting>
for models::ServersGameGuardRouting
{
impl ApiTryFrom<backend::ds::GameGuardRouting> for models::ServersGameGuardRouting {
type Error = GlobalError;

fn api_try_from(
value: backend::dynamic_servers::DockerGameGuardRouting,
value: backend::ds::GameGuardRouting,
) -> GlobalResult<models::ServersGameGuardRouting> {
Ok(models::ServersGameGuardRouting {
protocol: Some(
unwrap!(backend::dynamic_servers::GameGuardProtocol::from_i32(
value.protocol
))
.api_into(),
unwrap!(backend::ds::GameGuardProtocol::from_i32(value.protocol)).api_into(),
),
})
}
}

impl ApiFrom<models::ServersHostRouting> for backend::dynamic_servers::DockerHostRouting {
fn api_from(value: models::ServersHostRouting) -> backend::dynamic_servers::DockerHostRouting {
backend::dynamic_servers::DockerHostRouting {
protocol: backend::dynamic_servers::HostProtocol::api_from(
value.protocol.unwrap_or_default().into(),
) as i32,
impl ApiFrom<models::ServersHostRouting> for backend::ds::HostRouting {
fn api_from(value: models::ServersHostRouting) -> backend::ds::HostRouting {
backend::ds::HostRouting {
protocol: backend::ds::HostProtocol::api_from(value.protocol.unwrap_or_default().into())
as i32,
}
}
}

impl ApiTryFrom<backend::dynamic_servers::DockerHostRouting> for models::ServersHostRouting {
impl ApiTryFrom<backend::ds::HostRouting> for models::ServersHostRouting {
type Error = GlobalError;

fn api_try_from(
value: backend::dynamic_servers::DockerHostRouting,
) -> GlobalResult<models::ServersHostRouting> {
fn api_try_from(value: backend::ds::HostRouting) -> GlobalResult<models::ServersHostRouting> {
Ok(models::ServersHostRouting {
protocol: Some(
unwrap!(backend::dynamic_servers::HostProtocol::from_i32(
value.protocol
))
.api_into(),
),
protocol: Some(unwrap!(backend::ds::HostProtocol::from_i32(value.protocol)).api_into()),
})
}
}

impl ApiFrom<models::ServersGameGuardProtocol> for backend::dynamic_servers::GameGuardProtocol {
fn api_from(
value: models::ServersGameGuardProtocol,
) -> backend::dynamic_servers::GameGuardProtocol {
impl ApiFrom<models::ServersGameGuardProtocol> for backend::ds::GameGuardProtocol {
fn api_from(value: models::ServersGameGuardProtocol) -> backend::ds::GameGuardProtocol {
match value {
models::ServersGameGuardProtocol::Udp => {
backend::dynamic_servers::GameGuardProtocol::Udp
}
models::ServersGameGuardProtocol::Tcp => {
backend::dynamic_servers::GameGuardProtocol::Tcp
}
models::ServersGameGuardProtocol::Http => {
backend::dynamic_servers::GameGuardProtocol::Http
}
models::ServersGameGuardProtocol::Https => {
backend::dynamic_servers::GameGuardProtocol::Https
}
models::ServersGameGuardProtocol::TcpTls => {
backend::dynamic_servers::GameGuardProtocol::TcpTls
}
models::ServersGameGuardProtocol::Udp => backend::ds::GameGuardProtocol::Udp,
models::ServersGameGuardProtocol::Tcp => backend::ds::GameGuardProtocol::Tcp,
models::ServersGameGuardProtocol::Http => backend::ds::GameGuardProtocol::Http,
models::ServersGameGuardProtocol::Https => backend::ds::GameGuardProtocol::Https,
models::ServersGameGuardProtocol::TcpTls => backend::ds::GameGuardProtocol::TcpTls,
}
}
}

impl ApiFrom<backend::dynamic_servers::GameGuardProtocol> for models::ServersGameGuardProtocol {
fn api_from(
value: backend::dynamic_servers::GameGuardProtocol,
) -> models::ServersGameGuardProtocol {
impl ApiFrom<backend::ds::GameGuardProtocol> for models::ServersGameGuardProtocol {
fn api_from(value: backend::ds::GameGuardProtocol) -> models::ServersGameGuardProtocol {
match value {
backend::dynamic_servers::GameGuardProtocol::Udp => {
models::ServersGameGuardProtocol::Udp
}
backend::dynamic_servers::GameGuardProtocol::Tcp => {
models::ServersGameGuardProtocol::Tcp
}
backend::dynamic_servers::GameGuardProtocol::Http => {
models::ServersGameGuardProtocol::Http
}
backend::dynamic_servers::GameGuardProtocol::Https => {
models::ServersGameGuardProtocol::Https
}
backend::dynamic_servers::GameGuardProtocol::TcpTls => {
models::ServersGameGuardProtocol::TcpTls
}
backend::ds::GameGuardProtocol::Udp => models::ServersGameGuardProtocol::Udp,
backend::ds::GameGuardProtocol::Tcp => models::ServersGameGuardProtocol::Tcp,
backend::ds::GameGuardProtocol::Http => models::ServersGameGuardProtocol::Http,
backend::ds::GameGuardProtocol::Https => models::ServersGameGuardProtocol::Https,
backend::ds::GameGuardProtocol::TcpTls => models::ServersGameGuardProtocol::TcpTls,
}
}
}

impl ApiFrom<models::ServersHostProtocol> for backend::dynamic_servers::HostProtocol {
fn api_from(value: models::ServersHostProtocol) -> backend::dynamic_servers::HostProtocol {
impl ApiFrom<models::ServersHostProtocol> for backend::ds::HostProtocol {
fn api_from(value: models::ServersHostProtocol) -> backend::ds::HostProtocol {
match value {
models::ServersHostProtocol::Udp => backend::dynamic_servers::HostProtocol::HostUdp,
models::ServersHostProtocol::Tcp => backend::dynamic_servers::HostProtocol::HostTcp,
models::ServersHostProtocol::Udp => backend::ds::HostProtocol::HostUdp,
models::ServersHostProtocol::Tcp => backend::ds::HostProtocol::HostTcp,
}
}
}

impl ApiFrom<backend::dynamic_servers::HostProtocol> for models::ServersHostProtocol {
fn api_from(value: backend::dynamic_servers::HostProtocol) -> models::ServersHostProtocol {
impl ApiFrom<backend::ds::HostProtocol> for models::ServersHostProtocol {
fn api_from(value: backend::ds::HostProtocol) -> models::ServersHostProtocol {
match value {
backend::dynamic_servers::HostProtocol::HostUdp => models::ServersHostProtocol::Udp,
backend::dynamic_servers::HostProtocol::HostTcp => models::ServersHostProtocol::Tcp,
backend::ds::HostProtocol::HostUdp => models::ServersHostProtocol::Udp,
backend::ds::HostProtocol::HostTcp => models::ServersHostProtocol::Tcp,
}
}
}
Loading

0 comments on commit f25cffb

Please sign in to comment.