Provide delete chunk API using yproxy. (#41)

include/pg.h

@@ -119,6 +119,12 @@ extern "C" {
 
 #include "libpq/pqformat.h"
 
+#include "miscadmin.h"
+
+#include "libpq/libpq-be.h"
+
+#include "postmaster/postmaster.h"
+
 #ifdef __cplusplus
 }
 #endif

include/xvacuum.h

@@ -11,6 +11,6 @@
 #define EXTERNC
 #endif
 
-EXTERNC int yezzey_delete_chunk_internal(const char *external_chunk_path);
+EXTERNC int yezzey_delete_chunk_internal(const char *external_chunk_path, int segindx);
 
 #endif /* YEZZEY_XVACUUM_H */

include/ydeleter.h

@@ -0,0 +1,18 @@
+#pragma once
+
+#include <string>
+
+class YDeleter {
+public:
+  virtual ~YDeleter(){
+
+  };
+
+  // write() attempts to write up to count bytes from the buffer.
+  // Always return 0 if EOF, no matter how many times it's invoked. Throw
+  // exception if encounters errors.
+  virtual bool deleteChunk(const std::string &fn) = 0;
+
+  // This should be reentrant, has no side effects when called multiple times.
+  virtual bool close() = 0;
+};

include/yproxy.h

@@ -6,6 +6,7 @@
 #include "ylister.h"
 #include "yreader.h"
 #include "ywriter.h"
+#include "ydeleter.h"
 #include <memory>
 #include <string>
 #include <vector>
@@ -44,8 +45,7 @@ class YProxyReader : public YReader {
   int retry_limit{1};
 };
 
-// write to external storage, using gpwriter.
-// encrypt all data with gpg
+// Write into external storage using yproxy
 class YProxyWriter : public YWriter {
 public:
   explicit YProxyWriter(std::shared_ptr<IOadv> adv, ssize_t segindx,
@@ -62,12 +62,9 @@ class YProxyWriter : public YWriter {
   int prepareYproxyConnection();
   std::vector<char> ConstructPutRequest(std::string fileName);
   std::vector<char> ConstructCopyDataRequest(const char *buffer, size_t amount);
-  std::vector<char> CostructCommandCompleteRequest();
-  int readRFQResponce();
 
 private:
   std::string createXPath();
-  int write_full(const std::vector<char> &msg);
 
   std::shared_ptr<IOadv> adv_;
   ssize_t segindx_;
@@ -83,6 +80,32 @@ class YProxyWriter : public YWriter {
   XLogRecPtr getInsertionStorageLsn() { return insertion_rec_ptr_; }
 };
 
+
+
+/* Delete specified file from external storage, bypassing all sanity checks */
+class YProxyDeleter : public YDeleter {
+public:
+  explicit YProxyDeleter(std::shared_ptr<IOadv> adv, ssize_t segindx);
+
+  virtual ~YProxyDeleter();
+
+  virtual bool close();
+
+  virtual bool deleteChunk(const std::string &chunkName);
+
+protected:
+  /* prepare connection for chunk reading */
+  int prepareYproxyConnection();
+  std::vector<char> ConstructDeleteRequest(std::string fileName);
+
+private:
+  std::shared_ptr<IOadv> adv_;
+  ssize_t segindx_;
+
+  int client_fd_{-1};
+};
+
+
 // list external storage using yproxy
 class YProxyLister : public YLister {
 public:

src/xvacuum.cpp

@@ -1,5 +1,5 @@
 #include "xvacuum.h"
-#include "gpcleaner.h"
+#include "yproxy.h"
 #include "gucs.h"
 #include "pg.h"
 #include <string>
@@ -12,7 +12,7 @@
  * TBD: check, that chunk status is obsolete and other sanity checks
  * to avoid deleting chunk, which can we needed to read relation data
  */
-int yezzey_delete_chunk_internal(const char *external_chunk_path) {
+int yezzey_delete_chunk_internal(const char *external_chunk_path, int segindx) {
   try {
     auto ioadv = std::make_shared<IOadv>(
         std::string(gpg_engine_path), std::string(gpg_key_id),
@@ -23,16 +23,16 @@ int yezzey_delete_chunk_internal(const char *external_chunk_path) {
         "" /* coords */, InvalidOid /* reloid */, std::string(walg_bin_path),
         std::string(walg_config_path), use_gpg_crypto, yproxy_socket);
 
-    auto x_path = std::string(external_chunk_path);
-    auto init_url = getYezzeyExtrenalStorageBucket(ioadv->host.c_str(),
-                                                   ioadv->bucket.c_str()) +
-                    storage_url_add_options(x_path, ioadv->config_path.c_str());
+    std::string storage_path(external_chunk_path);
 
-    elog(LOG, "removing external chunk with url %s", init_url.c_str());
+    auto deleter =
+      std::make_shared<YProxyDeleter>(ioadv, ssize_t(segindx));
 
-    auto cleaner = cleaner_init(init_url.c_str());
-    int rc = cleaner->clean();
-    return rc;
+    if (deleter->deleteChunk(storage_path)) {
+      return 0;
+    }
+
+    return -1;
   } catch (...) {
     elog(ERROR, "failed to prepare x-storage reader for chunk");
     return 0;