add checking of account level on proxy

buildscripts/common.sh

@@ -3,6 +3,7 @@
 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,6 +1,7 @@
 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;
@@ -33,6 +34,24 @@ 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,6 +103,41 @@ 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,36 +3,33 @@ 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>{
-    _phantom: PhantomData<(MAJ, MIN)>
+struct Ver<MAJ: Unsigned, MIN: Unsigned> {
+    _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 where
+impl<T: Version, U: Version> ComparableVersion<T> for U
+where
     <T as Version>::Major: Cmp<Self::Major>,
     <T as Version>::Minor: IsLessOrEqual<Self::Minor>,
-    <T as Version>::Major: IsEqual<
-        Self::Major,
-        Output: BitAnd<
-            typenum::LeEq<T::Minor, Self::Minor>
-        >,
-    >,
+    <T as Version>::Major:
+        IsEqual<Self::Major, Output: BitAnd<typenum::LeEq<T::Minor, Self::Minor>>>,
     <T as Version>::Major: IsLess<
             Self::Major,
             Output: BitOr<
@@ -40,58 +37,59 @@ impl<T: Version, U: Version> ComparableVersion<T> for U where
                     typenum::Eq<T::Major, Self::Major>,
                     typenum::LeEq<T::Minor, Self::Minor>,
                 >,
-            Output: SameOrUnit
-        >
-    > {
-
+                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>{}
-
-impl<VER: Version, T: ComparableVersion<VER, IsAtLeast = typenum::True>> VersionIsAtLeast<VER> for T{}
+trait VersionIsAtLeast<VER: Version> {}
 
+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>>{
-    _phantom: PhantomData<(T, REQUIRED, VER)>
+struct MinVersionElementHelper<T, REQUIRED: Version, VER: Version + ComparableVersion<REQUIRED>> {
+    _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 for MinVersionElementHelper<T, REQUIRED, VER> where {
+impl<T, REQUIRED: Version, VER: Version + ComparableVersion<REQUIRED>> CondElemResult
+    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> = <MinVersionElementHelper<T, REQUIRED, VER> as CondElemResult>::Output;
+type MinVersion<T, REQUIRED, VER> =
+    <MinVersionElementHelper<T, REQUIRED, VER> as CondElemResult>::Output;