X-Git-Url: https://git.squeep.com/?a=blobdiff_plain;f=lib%2Fmix%2Ftasks%2Fpleroma%2Fsearch%2Fmeilisearch.ex;h=6730a99a90eb0a5da084d9765c90ffcd3281fefd;hb=bac70a2bc155e8c714b0ea3cf83acb9583b71ec0;hp=3704e0bdcad19f6bc6bcd084eaf13c8517397245;hpb=117f525fd6106ed7f16d4d6fcc687e1b53c0b81d;p=akkoma

diff --git a/lib/mix/tasks/pleroma/search/meilisearch.ex b/lib/mix/tasks/pleroma/search/meilisearch.ex
index 3704e0bdc..6730a99a9 100644
--- a/lib/mix/tasks/pleroma/search/meilisearch.ex
+++ b/lib/mix/tasks/pleroma/search/meilisearch.ex
@@ -3,120 +3,128 @@
 # SPDX-License-Identifier: AGPL-3.0-only
 
 defmodule Mix.Tasks.Pleroma.Search.Meilisearch do
-  require Logger
   require Pleroma.Constants
 
   import Mix.Pleroma
   import Ecto.Query
 
+  import Pleroma.Search.Meilisearch,
+    only: [meili_post: 2, meili_put: 2, meili_get: 1, meili_delete!: 1]
+
   def run(["index"]) do
     start_pleroma()
 
-    endpoint = Pleroma.Config.get([Pleroma.Search.Meilisearch, :url])
-
     {:ok, _} =
-      Pleroma.HTTP.post(
-        "#{endpoint}/indexes/objects/settings/ranking-rules",
-        Jason.encode!([
+      meili_post(
+        "/indexes/objects/settings/ranking-rules",
+        [
           "desc(published)",
-          "typo",
           "words",
+          "exactness",
           "proximity",
-          "attribute",
           "wordsPosition",
-          "exactness"
-        ])
+          "typo",
+          "attribute"
+        ]
       )
 
     {:ok, _} =
-      Pleroma.HTTP.post(
-        "#{endpoint}/indexes/objects/settings/searchable-attributes",
-        Jason.encode!([
+      meili_post(
+        "/indexes/objects/settings/searchable-attributes",
+        [
           "content"
-        ])
+        ]
       )
 
+    IO.puts("Created indices. Starting to insert posts.")
+
     chunk_size = 10_000
 
     Pleroma.Repo.transaction(
       fn ->
-        Pleroma.Repo.stream(
+        query =
           from(Pleroma.Object,
-            # Only index public posts which are notes and have some text
+            # Only index public and unlisted posts which are notes and have some text
             where:
               fragment("data->>'type' = 'Note'") and
-                fragment("LENGTH(data->>'content') > 0") and
-                fragment("data->'to' \\? ?", ^Pleroma.Constants.as_public()),
+                (fragment("data->'to' \\? ?", ^Pleroma.Constants.as_public()) or
+                   fragment("data->'cc' \\? ?", ^Pleroma.Constants.as_public())),
             order_by: [desc: fragment("data->'published'")]
-          ),
+          )
+
+        count = query |> Pleroma.Repo.aggregate(:count, :data)
+        IO.puts("Entries to index: #{count}")
+
+        Pleroma.Repo.stream(
+          query,
           timeout: :infinity
         )
+        |> Stream.map(&Pleroma.Search.Meilisearch.object_to_search_data/1)
+        |> Stream.filter(fn o -> not is_nil(o) end)
         |> Stream.chunk_every(chunk_size)
-        |> Stream.map(fn objects ->
-          Enum.map(objects, fn object ->
-            data = object.data
-
-            content_str =
-              case data["content"] do
-                [nil | rest] -> to_string(rest)
-                str -> str
-              end
-
-            {:ok, published, _} = DateTime.from_iso8601(data["published"])
-
-            content =
-              with {:ok, scrubbed} <- FastSanitize.strip_tags(content_str),
-                   trimmed <- String.trim(scrubbed) do
-                trimmed
-              end
-
-            # Only index if there is anything in the string. If there is a single symbol,
-            # it's probably a dot from mastodon posts with just the picture
-            if String.length(content) > 1 do
-              %{
-                id: object.id,
-                content: content,
-                ap: data["id"],
-                published: published |> DateTime.to_unix()
-              }
-            else
-              nil
-            end
-          end)
-          |> Enum.filter(fn o -> not is_nil(o) end)
-        end)
         |> Stream.transform(0, fn objects, acc ->
           new_acc = acc + Enum.count(objects)
 
-          IO.puts("Indexed #{new_acc} entries")
+          # Reset to the beginning of the line and rewrite it
+          IO.write("\r")
+          IO.write("Indexed #{new_acc} entries")
 
           {[objects], new_acc}
         end)
         |> Stream.each(fn objects ->
-          {:ok, result} =
-            Pleroma.HTTP.post(
-              "#{endpoint}/indexes/objects/documents",
-              Jason.encode!(objects)
+          result =
+            meili_put(
+              "/indexes/objects/documents",
+              objects
             )
 
-          if not Map.has_key?(Jason.decode!(result.body), "updateId") do
-            IO.puts("Failed to index: #{result}")
+          with {:ok, res} <- result do
+            if not Map.has_key?(res, "updateId") do
+              IO.puts("\nFailed to index: #{inspect(result)}")
+            end
+          else
+            e -> IO.puts("\nFailed to index due to network error: #{inspect(e)}")
           end
         end)
         |> Stream.run()
       end,
       timeout: :infinity
     )
+
+    IO.write("\n")
   end
 
   def run(["clear"]) do
     start_pleroma()
 
+    meili_delete!("/indexes/objects/documents")
+  end
+
+  def run(["show-private-key", master_key]) do
+    start_pleroma()
+
     endpoint = Pleroma.Config.get([Pleroma.Search.Meilisearch, :url])
 
-    {:ok, _} =
-      Pleroma.HTTP.request(:delete, "#{endpoint}/indexes/objects/documents", "", [],
-        timeout: :infinity
+    {:ok, result} =
+      Pleroma.HTTP.get(
+        Path.join(endpoint, "/keys"),
+        [{"X-Meili-API-Key", master_key}]
       )
+
+    decoded = Jason.decode!(result.body)
+
+    if decoded["private"] do
+      IO.puts(decoded["private"])
+    else
+      IO.puts("Error fetching the key, check the master key is correct: #{inspect(decoded)}")
+    end
+  end
+
+  def run(["stats"]) do
+    start_pleroma()
+
+    {:ok, result} = meili_get("/indexes/objects/stats")
+    IO.puts("Number of entries: #{result["numberOfDocuments"]}")
+    IO.puts("Indexing? #{result["isIndexing"]}")
   end
 end