buildscripts/common.sh

@@ -3,7 +3,6 @@
 set -euo pipefail
 
 TMP_FEATURES_TRAILINGCOMMA=$(yq ea ".$EDITION.features" editions.yaml  | sed 's/- //g' | tr '\n' ',')
-echo "tmpfeatures: $TMP_FEATURES_TRAILINGCOMMA"
 export EDITION_FEATURES=${TMP_FEATURES_TRAILINGCOMMA::-1}
 SETTINGS=$(yq ea ".$EDITION.settings" editions.yaml | yq 'keys[]')
 IFS=$'\n'

prudpv1/src/executables/proxy_secure.rs

@@ -1,7 +1,6 @@
 use crate::prudp::router::Router;
 use crate::prudp::secure::Secure;
 use log::error;
-use log::warn;
 use proxy_common::{ProxyStartupParam, RNEX_ACCESS_KEY};
 use rnex_core::executables::common::SECURE_SERVER_ACCOUNT;
 use rnex_core::prudp::virtual_port::VirtualPort;
@@ -34,24 +33,6 @@ pub async fn start(param: ProxyStartupParam) {
         };
 
         task::spawn(async move {
-            let Ok(mut c) = rnex_core::grpc::account::Client::new().await else {
-                error!("failed to initialize gql client");
-                return;
-            };
-
-            let v = match c.get_user_level(conn.user_id).await {
-                Ok(v) => v,
-                Err(e) => {
-                    error!("failed to get user level: {}", e);
-                    return;
-                }
-            };
-
-            if v < 0 {
-                warn!("person with too low account level joined");
-                return;
-            }
-
             let mut stream = match TcpStream::connect(param.forward_destination).await {
                 Ok(v) => v,
                 Err(e) => {

rnex-core/src/grpc/account.rs

@@ -103,41 +103,6 @@ impl Client {
         Ok(val.as_bytes().try_into().map_err(|_| SomethingHappened)?)
     }
 
-    pub async fn get_user_level(&mut self, pid: PID) -> Result<i32> {
-        let req = self
-            .do_request(object! {
-                "query": r"query($pid: Int!){
-                    userByPid(pid: $pid){
-                        accountLevel
-                    }
-                }",
-                "variables": {
-                    "pid": pid
-                }
-            })
-            .await?;
-
-        let Some(val) = req
-            .entries()
-            .find(|v| v.0 == "data")
-            .ok_or(SomethingHappened)?
-            .1
-            .entries()
-            .find(|v| v.0 == "userByPid")
-            .ok_or(SomethingHappened)?
-            .1
-            .entries()
-            .find(|v| v.0 == "accountLevel")
-            .ok_or(SomethingHappened)?
-            .1
-            .as_i32()
-        else {
-            return Err(SomethingHappened);
-        };
-
-        Ok(val)
-    }
-
     pub async fn get_pid_from_token(&mut self, token: String) -> Result<PID> {
         let req = self
             .do_request(object! {

rnex-core/src/versions.rs

@@ -3,93 +3,95 @@ use std::ops::{BitAnd, BitOr};
 use typenum::{Cmp, IsEqual, IsLess, IsLessOrEqual, Unsigned};
 
 /// This trait represents a version at compile time
-trait Version {
+trait Version{
     type Major: Unsigned;
     type Minor: Unsigned;
 }
 
 /// This struct contains nothing and is used to represent specific versions as an instance of
 /// [`Version`]. It is instances as `Ver<Major, Minor>`
-struct Ver<MAJ: Unsigned, MIN: Unsigned> {
+struct Ver<MAJ: Unsigned, MIN: Unsigned>{
-    _phantom: PhantomData<(MAJ, MIN)>,
+    _phantom: PhantomData<(MAJ, MIN)>
 }
 
-impl<MAJ: Unsigned, MIN: Unsigned> Version for Ver<MAJ, MIN> {
+impl<MAJ: Unsigned, MIN: Unsigned> Version for Ver<MAJ, MIN>{
     type Major = MAJ;
     type Minor = MIN;
 }
 
 /// Represents two versions which can be compared
-trait ComparableVersion<T: Version>: Version {
+trait ComparableVersion<T: Version>: Version{
     type IsAtLeast: SameOrUnit;
 }
 
-impl<T: Version, U: Version> ComparableVersion<T> for U
+impl<T: Version, U: Version> ComparableVersion<T> for U where
-where
     <T as Version>::Major: Cmp<Self::Major>,
     <T as Version>::Minor: IsLessOrEqual<Self::Minor>,
-    <T as Version>::Major:
+    <T as Version>::Major: IsEqual<
-        IsEqual<Self::Major, Output: BitAnd<typenum::LeEq<T::Minor, Self::Minor>>>,
+        Self::Major,
-    <T as Version>::Major: IsLess<
+        Output: BitAnd<
-            Self::Major,
+            typenum::LeEq<T::Minor, Self::Minor>
-            Output: BitOr<
-                typenum::And<
-                    typenum::Eq<T::Major, Self::Major>,
-                    typenum::LeEq<T::Minor, Self::Minor>,
-                >,
-                Output: SameOrUnit,
-            >,
         >,
-{
+    >,
+    <T as Version>::Major: IsLess<
+        Self::Major,
+        Output: BitOr<
+            typenum::And<
+                typenum::Eq<T::Major, Self::Major>,
+                typenum::LeEq<T::Minor, Self::Minor>,
+            >,
+            Output: SameOrUnit
+        >
+    > {
+
     type IsAtLeast = typenum::Or<
         typenum::Le<T::Major, Self::Major>,
-        typenum::And<typenum::Eq<T::Major, Self::Major>, typenum::LeEq<T::Minor, Self::Minor>>,
+        typenum::And<
+            typenum::Eq<T::Major, Self::Major>,
+            typenum::LeEq<T::Minor, Self::Minor>,
+        >
     >;
 }
 
+
 /// Simple check for testing if the `TEST` version is at least `REQ` or higher.
 type VersionAbove<REQ, TEST> = <TEST as ComparableVersion<REQ>>::IsAtLeast;
 
-trait VersionIsAtLeast<VER: Version> {}
+trait VersionIsAtLeast<VER: Version>{}
+
+impl<VER: Version, T: ComparableVersion<VER, IsAtLeast = typenum::True>> VersionIsAtLeast<VER> for T{}
 
-impl<VER: Version, T: ComparableVersion<VER, IsAtLeast = typenum::True>> VersionIsAtLeast<VER>
-    for T
-{
-}
 
 /// Trait for containing the result of elements which only conditionally exist
-trait CondElemResult {
+trait CondElemResult{
     type Output;
 }
 
 /// Empty helper struct which only servers to give a concrete type when creating fields in rmc
 /// structs which have a version requirement. This is not meant to be used directly, use
 /// [`MinVersion`] instead.
-struct MinVersionElementHelper<T, REQUIRED: Version, VER: Version + ComparableVersion<REQUIRED>> {
+struct MinVersionElementHelper<T, REQUIRED: Version, VER: Version + ComparableVersion<REQUIRED>>{
-    _phantom: PhantomData<(T, REQUIRED, VER)>,
+    _phantom: PhantomData<(T, REQUIRED, VER)>
 }
 
 /// This should be used either with [`typenum::True`] or [`typenum::False`]. When `True` the [`Self::Output`]
 /// will be the same as the `T` you put into Output. When `False` it will always be `()`
-trait SameOrUnit {
+trait SameOrUnit{
     type Output<T>;
 }
 
-impl SameOrUnit for typenum::True {
+impl SameOrUnit for typenum::True{
     type Output<T> = T;
 }
 
-impl SameOrUnit for typenum::False {
+impl SameOrUnit for typenum::False{
     type Output<T> = ();
 }
 
-impl<T, REQUIRED: Version, VER: Version + ComparableVersion<REQUIRED>> CondElemResult
+impl<T, REQUIRED: Version, VER: Version + ComparableVersion<REQUIRED>> CondElemResult for MinVersionElementHelper<T, REQUIRED, VER> where {
-    for MinVersionElementHelper<T, REQUIRED, VER>
-{
     type Output = <<VER as ComparableVersion<REQUIRED>>::IsAtLeast as SameOrUnit>::Output<T>;
 }
 
 /// When the version condition is met the field will exist and will simply be `T` if not it will be
 /// replaced by `()`. Use this when you need to add versioning to rmc structs.
-type MinVersion<T, REQUIRED, VER> =
+type MinVersion<T, REQUIRED, VER> = <MinVersionElementHelper<T, REQUIRED, VER> as CondElemResult>::Output;
-    <MinVersionElementHelper<T, REQUIRED, VER> as CondElemResult>::Output;