Suppression code inutilisé (support expérimental pour SIRI) (#5523)

Author: thbar

apps/transport/lib/transport_web/live/backoffice/proxy_config_live.ex

@@ -164,16 +164,6 @@ defmodule TransportWeb.Backoffice.ProxyConfigLive do
     }
   end
 
-  defp extract_config(proxy_base_url, %Unlock.Config.Item.SIRI{} = resource) do
-    %{
-      unique_slug: resource.identifier,
-      proxy_url: Transport.Proxy.resource_url(proxy_base_url, resource.identifier),
-      original_url: resource.target_url,
-      ttl: nil,
-      type: "SIRI"
-    }
-  end
-
   defp extract_config(proxy_base_url, %module{} = resource)
        when module == Unlock.Config.Item.DynamicIRVEAggregate do
     %{

apps/transport/lib/unlock/config.ex

@@ -27,16 +27,6 @@ defmodule Unlock.Config do
     ]
   end
 
-  defmodule Item.SIRI do
-    @moduledoc """
-    Intermediate structure for SIRI configured items.
-    """
-    @enforce_keys [:identifier, :target_url, :requestor_ref]
-
-    @type t :: %__MODULE__{identifier: binary(), target_url: binary(), requestor_ref: binary(), request_headers: list()}
-    defstruct [:identifier, :target_url, :requestor_ref, request_headers: []]
-  end
-
   defmodule Item.DynamicIRVEAggregate do
     @moduledoc """
     Intermediate structure for dynamic IRVE aggregated configured items.
@@ -102,15 +92,6 @@ defmodule Unlock.Config do
       }
     end
 
-    def convert_yaml_item_to_struct(%{"type" => "siri"} = item) do
-      %Item.SIRI{
-        identifier: Map.fetch!(item, "identifier"),
-        target_url: Map.fetch!(item, "target_url"),
-        requestor_ref: Map.fetch!(item, "requestor_ref"),
-        request_headers: parse_config_http_headers(Map.get(item, "request_headers", []))
-      }
-    end
-
     @doc """
     At the moment, GTFS-RT is just an alias for HTTP generic. This is done
     to make it easier to achieve alternate processing later if needed.

apps/transport/lib/unlock/controller.ex

@@ -14,7 +14,7 @@ defmodule Unlock.Controller do
 
   use Phoenix.Controller, formats: [html: "View", json: "View"]
   require Logger
-  import Unlock.GunzipTools
+  import Unlock.GunzipTools, only: [lowercase_headers: 1]
 
   @doc """
   A simple index "page", useful to verify that the proxy is up, since it is served
@@ -39,7 +39,6 @@ defmodule Unlock.Controller do
   - `%Unlock.Config.Item.Generic.HTTP{}` for HTTP-provided single GTFS-RT & CSV feeds
   - `%Unlock.Config.Item.DynamicIRVEAggregate{}` for the on-the-fly dynamic IRVE consolidation
   - `%Unlock.Config.Item.S3{}` for internal-S3-backed single file feeds (CSV or anything really)
-  - `%Unlock.Config.Item.SIRI{}` for SIRI proxying (experimental)
   - `%Unlock.Config.Item.GBFS{}` for GBFS feeds (with multiple endpoints)
 
   Once the item is found in configuration, different `process_resource` pattern-matching variants
@@ -203,41 +202,6 @@ defmodule Unlock.Controller do
 
   defp process_resource(conn, %Unlock.Config.Item.Generic.HTTP{}), do: send_not_allowed(conn)
 
-  # NOTE: this code is designed for private use for now. I have tracked
-  # what is required or useful for public opening later here:
-  # https://github.com/etalab/transport-site/issues/2476
-  #
-  # SIRI support is experimental. For now we are encouraging instead SIRI provider to
-  # get their game up and improve their ops & software, so that they can directly handle
-  # SIRI loads without the proxy.
-  #
-  # For SIRI, only `POST` is allowed since this is the protocol.
-  #
-  # The code analyses the incoming XML payload, & replace the `requestor_ref` (used sometimes
-  # as an API key) transparently with the one we have configured.
-  #
-  defp process_resource(%Plug.Conn{method: "POST"} = conn, %Unlock.Config.Item.SIRI{} = item) do
-    {:ok, body, conn} = Plug.Conn.read_body(conn, length: 1_000_000)
-
-    parsed = Unlock.SIRI.parse_incoming(body)
-
-    {modified_xml, external_requestor_refs} =
-      Unlock.SIRI.RequestorRefReplacer.replace_requestor_ref(parsed, item.requestor_ref)
-
-    # NOTE: here we assert both that the requestor ref is what is expected, but also that it
-    # is met once only. I am not deduping them at the moment on purpose, maybe we'll do that
-    # later based on experience.
-    if external_requestor_refs == [Application.fetch_env!(:transport, :unlock_siri_public_requestor_ref)] do
-      handle_authorized_siri_call(conn, item, modified_xml)
-    else
-      send_resp(conn, 403, "Forbidden")
-    end
-  end
-
-  # Forbid `GET` calls for SIRI, explicitely, since this is not the way to issue a SIRI call.
-  defp process_resource(%Plug.Conn{method: "GET"} = conn, %Unlock.Config.Item.SIRI{}),
-    do: send_not_allowed(conn)
-
   defp process_resource(%Plug.Conn{method: "GET"} = conn, %Unlock.Config.Item.GBFS{endpoint: nil}) do
     conn |> send_resp(404, "Not Found")
   end
@@ -277,30 +241,6 @@ defmodule Unlock.Controller do
     |> override_resp_headers_if_configured(item)
   end
 
-  @spec handle_authorized_siri_call(Plug.Conn.t(), Unlock.Config.Item.SIRI.t(), Saxy.XML.element()) :: Plug.Conn.t()
-  # The SIRI query is serialized into iodata, then a `POST` query is issued.
-  #
-  # On completion, we unzip if needed to smooth out implementations, filter response headers,
-  # and send back the answer to the client.
-  defp handle_authorized_siri_call(conn, %Unlock.Config.Item.SIRI{} = item, xml) do
-    body = Saxy.encode_to_iodata!(xml, version: "1.0")
-
-    response = Unlock.HTTP.Client.impl().post!(item.target_url, item.request_headers, body)
-
-    headers = response.headers |> lowercase_headers()
-
-    # NOTE: for now, we unzip systematically. This will make it easier
-    # to analyse payloads & later remove sensitive data, even if we
-    # re-zip afterwards.
-    body = maybe_gunzip(response.body, headers)
-
-    headers
-    |> filter_response_headers()
-    |> Enum.reduce(conn, fn {h, v}, c -> put_resp_header(c, h, v) end)
-    # No content-disposition as attachment for now
-    |> send_resp(response.status, body)
-  end
-
   # A wrapper grouping reused logic for two cases:
   # - `%Unlock.Config.Item.Generic.HTTP{}` (GTFS-RT, external CSV etc)
   # - `%Unlock.Config.Item.S3{}` (internal S3 backend)

apps/transport/lib/unlock/http_client.ex

@@ -29,7 +29,6 @@ defmodule Unlock.HTTP do
     @type headers() :: [{header_name :: String.t(), header_value :: String.t()}]
 
     @callback get!(url :: binary, headers :: headers(), options :: keyword()) :: any()
-    @callback post!(url :: binary, headers :: headers(), body :: binary) :: any()
     @callback stream!(url :: binary, headers :: headers(), path :: binary) :: Unlock.HTTP.Response.t()
 
     def impl, do: Application.fetch_env!(:transport, :unlock_http_client)
@@ -119,18 +118,5 @@ defmodule Unlock.HTTP do
         response
       end
     end
-
-    def post!(url, headers, body) do
-      {:ok, response} =
-        :post
-        |> Finch.build(url, headers, body)
-        |> Finch.request(@my_finch)
-
-      %Response{
-        body: response.body,
-        status: response.status,
-        headers: response.headers
-      }
-    end
   end
 end

apps/transport/lib/unlock/siri.ex

@@ -23,9 +23,8 @@ defmodule Transport.SIRITest do
   Elixir structures, and removing the non-significant newlines.
   """
   def parse_xml(payload) do
-    payload
-    |> Unlock.SIRI.parse_incoming()
-    |> XMLNewlinesRemover.filter_newlines_from_model()
+    {:ok, parsed} = Saxy.SimpleForm.parse_string(payload, cdata_as_characters: false)
+    XMLNewlinesRemover.filter_newlines_from_model(parsed)
   end
 
   test "CheckStatus" do