Merge pull request #6 from andreibondarev/backups-endpoint

Backups endpoint

Author: andreibondarev

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    weaviate-ruby (0.4.0)
+    weaviate-ruby (0.5.0)
       faraday (~> 2.7)
       graphlient (~> 0.7.0)
 

README.md

@@ -134,6 +134,16 @@ response = client.objects.batch_create(objects: [
     }
 ])
 response.data
+
+# Batch delete objects
+client.objects.batch_delete(
+    class_name: "Question",
+    where: {
+        valueString: "1",
+        operator: "Equal",
+        path: ["id"]
+    }
+)
 ```
 
 ### Querying
@@ -201,6 +211,30 @@ client.classifications.get(
 )
 ```
 
+### Backups
+```ruby
+client.backups.create(
+    backend: "filesystem",
+    id: "my-first-backup",
+    include: ["Question"]
+)
+
+client.backups.get(
+    backend: "filesystem",
+    id: "my-first-backup"
+)
+
+client.backups.restore(
+    backend: "filesystem",
+    id: "my-first-backup"
+)
+
+client.backups.restore_status(
+    backend: "filesystem",
+    id: "my-first-backup"
+)
+```
+
 ### Nodes
 ```ruby
 client.nodes

lib/weaviate.rb

@@ -14,6 +14,7 @@ module Weaviate
   autoload :Nodes, "weaviate/nodes"
   autoload :Health, "weaviate/health"
   autoload :Classifications, "weaviate/classifications"
+  autoload :Backups, "weaviate/backups"
 
   module Response
     autoload :Base, "weaviate/response/base"

lib/weaviate/backups.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Weaviate
+  class Backups < Base
+    PATH = "backups"
+
+    def create(
+      backend:,
+      id:,
+      include: nil,
+      exclude: nil
+    )
+      response = client.connection.post("#{PATH}/#{backend}") do |req|
+        req.body = {}
+        req.body["id"] = id
+        req.body["include"] = include if include
+        req.body["exclude"] = exclude if exclude
+      end
+
+      response.body
+    end
+
+    def get(
+      backend:,
+      id:
+    )
+      response = client.connection.get("#{PATH}/#{backend}/#{id}")
+      response.body
+    end
+
+    def restore(
+      backend:,
+      id:,
+      include: nil,
+      exclude: nil
+    )
+      response = client.connection.post("#{PATH}/#{backend}/#{id}/restore") do |req|
+        req.body = {}
+        req.body["include"] = include if include
+        req.body["exclude"] = exclude if exclude
+      end
+
+      response.body
+    end
+
+    def restore_status(
+      backend:,
+      id:
+    )
+      response = client.connection.get("#{PATH}/#{backend}/#{id}/restore")
+      response.body
+    end
+  end
+end

lib/weaviate/client.rb

@@ -59,6 +59,10 @@ def ready?
       @health.ready?
     end
 
+    def backups
+      @backups ||= Weaviate::Backups.new(client: self)
+    end
+
     def classifications
       @classifications ||= Weaviate::Classifications.new(client: self)
     end

lib/weaviate/objects.rb

@@ -108,6 +108,30 @@ def delete(class_name:, id:)
       response.success? && response.body.empty?
     end
 
+    def batch_delete(
+      class_name:,
+      where:,
+      consistency_level: nil,
+      output: nil,
+      dry_run: nil
+    )
+      path = "batch/#{PATH}"
+      path << "?consistency_level=#{consistency_level}" unless consistency_level.nil?
+
+      response = client.connection.delete(path) do |req|
+        req.body = {
+          match: {
+            class: class_name,
+            where: where
+          }
+        }
+        req.body["output"] = output unless output.nil?
+        req.body["dryRun"] = dry_run unless dry_run.nil?
+      end
+
+      response.body
+    end
+
     # Validate a data object
     # def validate
     # end

lib/weaviate/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Weaviate
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

spec/fixtures/backup.json

@@ -0,0 +1,7 @@
+{
+  "backend": "filesystem",
+  "classes": ["Question"],
+  "id": "my-first-backup",
+  "path": "/var/lib/weaviate/backups/my-first-backup",
+  "status": "STARTED"
+}

spec/fixtures/batch_delete_object.json

@@ -0,0 +1,20 @@
+{
+  "dryRun": false,
+  "match": {
+    "class": "Question",
+    "where": {
+      "operands": null,
+      "operator": "Equal",
+      "path": ["id"],
+      "valueString": "1"
+    }
+  },
+  "output": "minimal",
+  "results": {
+    "failed": 0,
+    "limit": 10000,
+    "matches": 1,
+    "objects": null,
+    "successful": 1
+  }
+}

spec/weaviate/backups_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe Weaviate::Backups do
+  let(:client) {
+    Weaviate::Client.new(
+      scheme: "http",
+      host: "localhost:8080"
+    )
+  }
+
+  let(:backups) { client.backups }
+  let(:backup_fixture) { JSON.parse(File.read("spec/fixtures/backup.json")) }
+
+  describe "#create" do
+    let(:response) { OpenStruct.new(success?: true, body: backup_fixture) }
+
+    before do
+      allow_any_instance_of(Faraday::Connection).to receive(:post)
+        .with("backups/filesystem")
+        .and_return(response)
+    end
+
+    it "creates the backup" do
+      response = backups.create(
+        backend: "filesystem",
+        id: "my-first-backup",
+        include: ["Question"]
+      )
+      expect(response["id"]).to eq("my-first-backup")
+      expect(response["status"]).to eq("STARTED")
+    end
+  end
+
+  describe "#get" do
+    let(:response) { OpenStruct.new(success?: true, body: backup_fixture) }
+
+    before do
+      allow_any_instance_of(Faraday::Connection).to receive(:get)
+        .with("backups/filesystem/my-first-backup")
+        .and_return(response)
+    end
+
+    it "returns the backup" do
+      response = backups.get(
+        backend: "filesystem",
+        id: "my-first-backup"
+      )
+      expect(response["id"]).to eq("my-first-backup")
+    end
+  end
+
+  describe "#restore" do
+    let(:response) { OpenStruct.new(success?: true, body: backup_fixture) }
+
+    before do
+      allow_any_instance_of(Faraday::Connection).to receive(:post)
+        .with("backups/filesystem/my-first-backup/restore")
+        .and_return(response)
+    end
+
+    it "restores the backup" do
+      response = backups.restore(
+        backend: "filesystem",
+        id: "my-first-backup",
+        include: ["Question"]
+      )
+      expect(response["id"]).to eq("my-first-backup")
+      expect(response["status"]).to eq("STARTED")
+    end
+  end
+
+  describe "#restore_status" do
+    let(:response) { OpenStruct.new(success?: true, body: backup_fixture) }
+
+    before do
+      allow_any_instance_of(Faraday::Connection).to receive(:get)
+        .with("backups/filesystem/my-first-backup/restore")
+        .and_return(response)
+    end
+
+    it "returns the restore status" do
+      response = backups.restore_status(
+        backend: "filesystem",
+        id: "my-first-backup"
+      )
+      expect(response["id"]).to eq("my-first-backup")
+    end
+  end
+end