dan/per-12465-upgrade-pdp-websockets-to-v15 (permitio#276)

* Changed OPAL to 0.8.1rc1

* Updated Makefile

* Removed scripts directory

* Fixed clippy issues

* Upgrade opal-common and opal-client to version 0.8.1

Author: danyi1212

Makefile

@@ -1,4 +1,4 @@
-.PHONY: help build prepare
+.PHONY: help build prepare build-amd64 build-arm64
 
 .DEFAULT_GOAL := help
 

pdp-server/src/api/authn_middleware.rs

@@ -33,10 +33,7 @@ pub(super) async fn authentication_middleware(
             header_str[7..].to_string()
         }
         Ok(header_str) => {
-            warn!(
-                "Invalid Authorization header format, missing 'Bearer ' prefix: {}",
-                header_str
-            );
+            warn!("Invalid Authorization header format, missing 'Bearer ' prefix: {header_str}");
             return Response::builder()
                 .status(StatusCode::FORBIDDEN)
                 .body(
@@ -46,7 +43,7 @@ pub(super) async fn authentication_middleware(
                 .expect("Failed to create response");
         }
         Err(e) => {
-            warn!("Failed to parse Authorization header to string: {}", e);
+            warn!("Failed to parse Authorization header to string: {e}");
             return Response::builder()
                 .status(StatusCode::FORBIDDEN)
                 .body(

pdp-server/src/api/authz/allowed.rs

@@ -36,7 +36,7 @@ pub(super) async fn allowed_handler(
     match query_allowed_cached(&state, &query, &cache_control).await {
         Ok(result) => (StatusCode::OK, Json(result)).into_response(),
         Err(err) => {
-            log::error!("Failed to send request to OPA: {}", err);
+            log::error!("Failed to send request to OPA: {err}");
             ApiError::from(err).into_response()
         }
     }

pdp-server/src/api/authz/allowed_bulk.rs

@@ -36,7 +36,7 @@ pub(super) async fn allowed_bulk_handler(
     match query_allowed_bulk_cached(&state, &queries, &cache_control).await {
         Ok(result) => (StatusCode::OK, Json(result)).into_response(),
         Err(err) => {
-            log::error!("Failed to send request to OPA: {}", err);
+            log::error!("Failed to send request to OPA: {err}");
             ApiError::from(err).into_response()
         }
     }

pdp-server/src/api/authz/authorized_users.rs

@@ -39,7 +39,7 @@ pub(super) async fn authorized_users_handler(
     match query_authorized_users_cached(&state, &query, &cache_control).await {
         Ok(result) => (StatusCode::OK, Json(result)).into_response(),
         Err(err) => {
-            log::error!("Failed to send request to OPA: {}", err);
+            log::error!("Failed to send request to OPA: {err}");
             ApiError::from(err).into_response()
         }
     }

pdp-server/src/api/authz/user_permissions.rs

@@ -56,7 +56,7 @@ pub(super) async fn user_permissions_handler(
     let permissions = match query_user_permissions_cached(&state, &query, &cache_control).await {
         Ok(permissions) => permissions,
         Err(err) => {
-            log::error!("Failed to send request to OPA: {}", err);
+            log::error!("Failed to send request to OPA: {err}");
             return ApiError::from(err).into_response();
         }
     };

pdp-server/src/api/authzen/errors.rs

@@ -88,7 +88,7 @@ impl From<crate::errors::ApiError> for AuthZenError {
             StatusCode::FORBIDDEN => AuthZenError::forbidden("Access denied"),
             StatusCode::BAD_REQUEST => AuthZenError::invalid_request(err.detail),
             _ => {
-                log::error!("Internal error converted to AuthZen format: {:?}", err);
+                log::error!("Internal error converted to AuthZen format: {err:?}");
                 AuthZenError::internal_error("Internal server error")
             }
         }
@@ -98,7 +98,7 @@ impl From<crate::errors::ApiError> for AuthZenError {
 /// Convert OPA forwarding errors to AuthZen format
 impl From<crate::opa_client::ForwardingError> for AuthZenError {
     fn from(err: crate::opa_client::ForwardingError) -> Self {
-        log::error!("OPA forwarding error: {:?}", err);
+        log::error!("OPA forwarding error: {err:?}");
         // Use generic message to avoid leaking internal implementation details
         AuthZenError::internal_error("Internal server error")
     }

pdp-server/src/api/authzen/evaluation.rs

@@ -108,7 +108,7 @@ pub async fn access_evaluation_handler(
             (StatusCode::OK, Json(authzen_response)).into_response()
         }
         Err(err) => {
-            log::error!("Failed to process AuthZen request: {}", err);
+            log::error!("Failed to process AuthZen request: {err}");
             let authzen_error = AuthZenError::from(err);
             authzen_error.into_response()
         }
@@ -700,13 +700,11 @@ mod tests {
         // Verify it's a plain string, not JSON
         assert!(
             !error_response_text.starts_with("{"),
-            "AuthZen errors must be plain strings per spec section 12.1.11, got: {}",
-            error_response_text
+            "AuthZen errors must be plain strings per spec section 12.1.11, got: {error_response_text}"
         );
         assert!(
             !error_response_text.contains("\"error\""),
-            "AuthZen errors must not be structured JSON, got: {}",
-            error_response_text
+            "AuthZen errors must not be structured JSON, got: {error_response_text}"
         );
 
         // The error message should be our generic internal server error message

pdp-server/src/api/authzen/evaluations.rs

@@ -215,7 +215,7 @@ pub async fn access_evaluations_handler(
         }
 
         error_msg.push_str("\nPlease provide all required fields (subject, resource, action) either in individual evaluations or at the request level.");
-        log::warn!("{}", error_msg);
+        log::warn!("{error_msg}");
         let authzen_error = AuthZenError::invalid_request(&error_msg);
         return authzen_error.into_response();
     }
@@ -234,7 +234,7 @@ pub async fn access_evaluations_handler(
             (StatusCode::OK, Json(response)).into_response()
         }
         Err(err) => {
-            log::error!("Failed to process AuthZen evaluations request: {:?}", err);
+            log::error!("Failed to process AuthZen evaluations request: {err:?}");
             let authzen_error = AuthZenError::from(err);
             authzen_error.into_response()
         }

pdp-server/src/api/authzen/metadata.rs

@@ -47,15 +47,15 @@ pub async fn authzen_metadata_handler(request: Request<Body>) -> Response {
         .or_else(|| uri_parts.authority.as_ref().map(|auth| auth.to_string()))
         .unwrap_or_else(|| "localhost:7766".to_string());
 
-    let base_url = format!("{}://{}", scheme, authority);
+    let base_url = format!("{scheme}://{authority}");
 
     let metadata = AuthZenMetadataResponse {
         policy_decision_point: base_url.clone(),
-        access_evaluation_endpoint: format!("{}/access/v1/evaluation", base_url),
-        access_evaluations_endpoint: format!("{}/access/v1/evaluations", base_url),
-        search_subject_endpoint: format!("{}/access/v1/search/subject", base_url),
-        search_resource_endpoint: format!("{}/access/v1/search/resource", base_url),
-        search_action_endpoint: format!("{}/access/v1/search/action", base_url),
+        access_evaluation_endpoint: format!("{base_url}/access/v1/evaluation"),
+        access_evaluations_endpoint: format!("{base_url}/access/v1/evaluations"),
+        search_subject_endpoint: format!("{base_url}/access/v1/search/subject"),
+        search_resource_endpoint: format!("{base_url}/access/v1/search/resource"),
+        search_action_endpoint: format!("{base_url}/access/v1/search/action"),
     };
     (StatusCode::OK, Json(metadata)).into_response()
 }
@@ -140,23 +140,23 @@ mod tests {
         assert_eq!(metadata.policy_decision_point, expected_base);
         assert_eq!(
             metadata.access_evaluation_endpoint,
-            format!("{}/access/v1/evaluation", expected_base)
+            format!("{expected_base}/access/v1/evaluation")
         );
         assert_eq!(
             metadata.access_evaluations_endpoint,
-            format!("{}/access/v1/evaluations", expected_base)
+            format!("{expected_base}/access/v1/evaluations")
         );
         assert_eq!(
             metadata.search_subject_endpoint,
-            format!("{}/access/v1/search/subject", expected_base)
+            format!("{expected_base}/access/v1/search/subject")
         );
         assert_eq!(
             metadata.search_action_endpoint,
-            format!("{}/access/v1/search/action", expected_base)
+            format!("{expected_base}/access/v1/search/action")
         );
         assert_eq!(
             metadata.search_resource_endpoint,
-            format!("{}/access/v1/search/resource", expected_base)
+            format!("{expected_base}/access/v1/search/resource")
         );
     }
 }