linting

Author: polvorin

implementations/elixir/ockam/ockam/lib/ockam/secure_channel/channel.ex

@@ -540,47 +540,48 @@ defmodule Ockam.SecureChannel.Channel do
   end
 
   defp handle_inner_message_impl(message, %Channel{channel_state: channel_state} = state) do
-    with {:ok, plaintext, decrypt_st} <-
-           Decryptor.decrypt("", message.payload, channel_state.decrypt_st) do
-      case Messages.decode(plaintext) do
-        {:ok, %Messages.Payload{} = payload} ->
-          message = struct(Ockam.Message, Map.from_struct(payload))
-
-          handle_decrypted_message(message, %Channel{
-            state
-            | channel_state: %{channel_state | decrypt_st: decrypt_st}
-          })
-
-        {:ok, :close} ->
-          Logger.debug("Peer closed secure channel, terminating #{inspect(state.address)}")
-          {:stop, :normal, channel_state}
-
-        ## TODO: add tests
-        {:ok, %Messages.RefreshCredentials{contact: contact, credentials: credentials}} ->
-          with {:ok, peer_identity, peer_identity_id} <- Identity.validate_contact_data(contact),
-               true <- peer_identity_id == channel_state.peer_identity_id,
-               :ok <- process_credentials(credentials, peer_identity_id, state.authorities) do
-            {:ok,
-             %Channel{
-               state
-               | channel_state: %{
-                   channel_state
-                   | peer_identity: peer_identity,
-                     decrypt_st: decrypt_st
-                 }
-             }}
-          else
-            error ->
-              Logger.warning("Invalid credential refresh: #{inspect(error)}")
-              {:stop, {:error, :invalid_credential_refresh}, state}
-          end
-
-        {:error, reason} ->
-          {:error, reason}
-      end
-    else
-      # The message couldn't be decrypted.  State remains unchanged
+    case Decryptor.decrypt("", message.payload, channel_state.decrypt_st) do
+      {:ok, plaintext, decrypt_st} ->
+        case Messages.decode(plaintext) do
+          {:ok, %Messages.Payload{} = payload} ->
+            message = struct(Ockam.Message, Map.from_struct(payload))
+
+            handle_decrypted_message(message, %Channel{
+              state
+              | channel_state: %{channel_state | decrypt_st: decrypt_st}
+            })
+
+          {:ok, :close} ->
+            Logger.debug("Peer closed secure channel, terminating #{inspect(state.address)}")
+            {:stop, :normal, channel_state}
+
+          ## TODO: add tests
+          {:ok, %Messages.RefreshCredentials{contact: contact, credentials: credentials}} ->
+            with {:ok, peer_identity, peer_identity_id} <-
+                   Identity.validate_contact_data(contact),
+                 true <- peer_identity_id == channel_state.peer_identity_id,
+                 :ok <- process_credentials(credentials, peer_identity_id, state.authorities) do
+              {:ok,
+               %Channel{
+                 state
+                 | channel_state: %{
+                     channel_state
+                     | peer_identity: peer_identity,
+                       decrypt_st: decrypt_st
+                   }
+               }}
+            else
+              error ->
+                Logger.warning("Invalid credential refresh: #{inspect(error)}")
+                {:stop, {:error, :invalid_credential_refresh}, state}
+            end
+
+          {:error, reason} ->
+            {:error, reason}
+        end
+
       error ->
+        # The message couldn't be decrypted.  State remains unchanged
         Logger.warning("Failed to decrypt message, discarded: #{inspect(error)}")
         {:ok, state}
     end

implementations/elixir/ockam/ockam/lib/ockam/secure_channel/messages.ex

@@ -71,6 +71,9 @@ defmodule Ockam.SecureChannel.Messages do
   end
 
   defmodule PaddedMessage do
+    @moduledoc """
+    Top-level secure channel message, with padding support.
+    """
     use TypedStruct
 
     @enum_schema {:variant_enum,

implementations/elixir/ockam/ockam/lib/ockam/transport/tcp/client.ex

@@ -166,8 +166,6 @@ defmodule Ockam.Transport.TCP.Client do
 
   @impl true
   def handle_message(%{payload: _payload} = message, state) do
-    Logger.info("Attempting to send #{inspect(message)}")
-
     with :ok <- encode_and_send_over_tcp(message, state) do
       {:ok, state}
     end

implementations/elixir/ockam/ockam/lib/ockam/transport/tcp/transport_message.ex

@@ -46,16 +46,22 @@ defmodule Ockam.Transport.TCP.TransportMessage do
 
   @spec decode(binary()) :: {:ok, Message.t()} | {:error, any()}
   def decode(data) do
-    with {:ok, msg} <- TCPMessage.decode_strict(data) do
-      {:ok,
-       %Message{
-         onward_route: msg.onward_route,
-         return_route: msg.return_route,
-         payload: msg.payload,
-         local_metadata: %{source: :channel, channel: :tcp, tracing_context: msg.tracing_context}
-       }}
-    else
-      x -> {:error, {:error_decoding_msg, x}}
+    case TCPMessage.decode_strict(data) do
+      {:ok, msg} ->
+        {:ok,
+         %Message{
+           onward_route: msg.onward_route,
+           return_route: msg.return_route,
+           payload: msg.payload,
+           local_metadata: %{
+             source: :channel,
+             channel: :tcp,
+             tracing_context: msg.tracing_context
+           }
+         }}
+
+      error ->
+        {:error, {:error_decoding_msg, error}}
     end
   end
 
@@ -65,7 +71,6 @@ defmodule Ockam.Transport.TCP.TransportMessage do
       onward_route: o,
       return_route: r,
       payload: p,
-      # payload: :bare.encode(p, :data),
       tracing_context: Map.get(l, :tracing_context, nil)
     })
   end