[ceph.git] / ceph / src / test / librgw_file_gp.cc

// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
 * Ceph - scalable distributed file system
 *
 * Copyright (C) 2015 Red Hat, Inc.
 *
 * This is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License version 2.1, as published by the Free Software
 * Foundation.  See file COPYING.
 *
 */

#include <stdint.h>
#include <tuple>
#include <iostream>
#include <vector>
#include <map>
#include <random>
#include "xxhash.h"

#include "include/rados/librgw.h"
#include "include/rados/rgw_file.h"

#include "gtest/gtest.h"
#include "common/ceph_argparse.h"
#include "common/debug.h"

#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_rgw

namespace {
  librgw_t rgw = nullptr;
  string uid("testuser");
  string access_key("");
  string secret_key("");
  struct rgw_fs *fs = nullptr;

  bool do_pre_list = false;
  bool do_put = false;
  bool do_bulk = false;
  bool do_writev = false;
  bool do_readv = false;
  bool do_verify = false;
  bool do_get = false;
  bool do_create = false;
  bool do_delete = false;
  bool do_stat = false; // stat objects (not buckets)
  bool do_hexdump = false;

  bool object_open = false;

  uint32_t owner_uid = 867;
  uint32_t owner_gid = 5309;
  uint32_t create_mask = RGW_SETATTR_UID | RGW_SETATTR_GID | RGW_SETATTR_MODE;

  string bucket_name = "blastoff";
  string object_name = "jocaml";

  struct rgw_file_handle *bucket_fh = nullptr;
  struct rgw_file_handle *object_fh = nullptr;

  typedef std::tuple<string,uint64_t, struct rgw_file_handle*> fid_type;
  std::vector<fid_type> fids;

  std::uniform_int_distribution<uint8_t> uint_dist;
  std::mt19937 rng;

  constexpr int iovcnt = 16;
  constexpr int page_size = 65536;
  constexpr int seed = 8675309;

  struct ZPage
  {
    char data[page_size];
    uint64_t cksum;
  }; /* ZPage */
  
  struct ZPageSet
  {
    std::vector<ZPage*> pages;
    struct iovec* iovs;

    explicit ZPageSet(int n) {
      pages.reserve(n);
      iovs = (struct iovec*) calloc(n, sizeof(struct iovec));
      for (int page_ix = 0; page_ix < n; ++page_ix) {
	ZPage* p = new ZPage();
	for (int data_ix = 0; data_ix < page_size; ++data_ix) {
	  p->data[data_ix] = uint_dist(rng);
	} // data_ix
	p->cksum = XXH64(p->data, page_size, seed);
	pages.emplace_back(p);
	// and iovs
	struct iovec* iov = &iovs[page_ix];
	iov->iov_base = p->data;
	iov->iov_len = page_size;
      } // page_ix
    }

    int size() { return pages.size(); }

    struct iovec* get_iovs() { return iovs; }

    bool operator==(const ZPageSet& rhs) {
      int n = size();
      for (int page_ix = 0; page_ix < n; ++page_ix) {
	ZPage* p1 = pages[page_ix];
	ZPage* p2 = rhs.pages[page_ix];
	if (p1->cksum != p2->cksum)
	  return false;
      }
      return true;
    }

    bool operator==(const rgw_uio* uio) {
      uint64_t cksum;
      int vix = 0, off = 0;
      rgw_vio* vio = &uio->uio_vio[vix];
      int vio_len = vio->vio_len;
      char *data;

      for (int ix = 0; ix < iovcnt; ++ix) {
	ZPage* p1 = pages[ix];
	data = static_cast<char*>(vio->vio_base) + off;
	cksum = XXH64(data, page_size, seed);

	if (p1->cksum != cksum) {
	  int r = memcmp(data, p1->data, page_size);
	  std::cout << "problem at ix " << ix << " r " << r<< std::endl;
	  return false;
	}

	off += page_size;
	if (off >= vio_len) {
	  vio = &uio->uio_vio[++vix];
	  vio_len = vio->vio_len;
	  off = 0;
	}
      }
      return true;
    }
    
    void cksum() {
      int n = size();
      for (int page_ix = 0; page_ix < n; ++page_ix) {
	ZPage* p = pages[page_ix];
	p->cksum = XXH64(p->data, page_size, seed);
      }
    }

    void reset_iovs() { // VOP_READ and VOP_WRITE update
      int n = size();
      for (int page_ix = 0; page_ix < n; ++page_ix) {
	ZPage* p = pages[page_ix];
	struct iovec* iov = &iovs[page_ix];
	iov->iov_base = p->data;
	iov->iov_len = page_size;
      }
    }

    ~ZPageSet() {
      for (unsigned int ix = 0; ix < pages.size(); ++ix)
	delete pages[ix];
      free(iovs);
    }
  }; /* ZPageSet */

  rgw_uio uio[1];
  ZPageSet zp_set1{iovcnt}; // 1M random data in 16 64K pages

  struct {
    int argc;
    char **argv;
  } saved_args;
}

TEST(LibRGW, INIT) {
  int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
  ASSERT_EQ(ret, 0);
  ASSERT_NE(rgw, nullptr);
}

TEST(LibRGW, MOUNT) {
  int ret = rgw_mount2(rgw, uid.c_str(), access_key.c_str(), secret_key.c_str(),
                       "/", &fs, RGW_MOUNT_FLAG_NONE);
  ASSERT_EQ(ret, 0);
  ASSERT_NE(fs, nullptr);
}

TEST(LibRGW, CREATE_BUCKET) {
  if (do_create) {
    struct stat st;
    struct rgw_file_handle *fh;

    st.st_uid = owner_uid;
    st.st_gid = owner_gid;
    st.st_mode = 755;

    int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
			&fh, RGW_MKDIR_FLAG_NONE);
    ASSERT_EQ(ret, 0);
  }
}

TEST(LibRGW, LOOKUP_BUCKET) {
  int ret = rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
		       nullptr, 0, RGW_LOOKUP_FLAG_NONE);
  ASSERT_EQ(ret, 0);
}

extern "C" {
  static bool r2_cb(const char* name, void *arg, uint64_t offset,
		    struct stat *st, uint32_t st_mask,
		    uint32_t flags) {
    // don't need arg--it would point to fids
    fids.push_back(fid_type(name, offset, nullptr));
    return true; /* XXX ? */
  }
}

TEST(LibRGW, LIST_OBJECTS) {
  if (do_pre_list) {
    /* list objects via readdir, bucketwise */
    using std::get;

    ldout(g_ceph_context, 0) << __func__ << " readdir on bucket "
			     << bucket_name << dendl;
    bool eof = false;
    uint64_t offset = 0;
    int ret = rgw_readdir(fs, bucket_fh, &offset, r2_cb, &fids,
			  &eof, RGW_READDIR_FLAG_NONE);
    for (auto& fid : fids) {
      std::cout << "fname: " << get<0>(fid) << " fid: " << get<1>(fid)
		<< std::endl;
    }
    ASSERT_EQ(ret, 0);
  }
}

TEST(LibRGW, LOOKUP_OBJECT) {
  if (do_get || do_stat || do_put || do_bulk || do_readv || do_writev) {
    int ret = rgw_lookup(fs, bucket_fh, object_name.c_str(), &object_fh,
			 nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
    ASSERT_EQ(ret, 0);
  }
}

TEST(LibRGW, OBJ_OPEN) {
  if (do_get || do_put || do_readv || do_writev) {
    int ret = rgw_open(fs, object_fh, 0 /* posix flags */, 0 /* flags */);
    ASSERT_EQ(ret, 0);
    object_open = true;
  }
}

TEST(LibRGW, PUT_OBJECT) {
  if (do_put) {
    size_t nbytes;
    string data = "hi mom"; // fix this
    int ret = rgw_write(fs, object_fh, 0, data.length(), &nbytes,
			(void*) data.c_str(), RGW_WRITE_FLAG_NONE);
    ASSERT_EQ(ret, 0);
    ASSERT_EQ(nbytes, data.length());
    /* commit write transaction */
    ret = rgw_close(fs, object_fh, 0 /* flags */);
    ASSERT_EQ(ret, 0);
  }
}

TEST(LibRGW, GET_OBJECT) {
  if (do_get) {
    char sbuf[512];
    memset(sbuf, 0, 512);
    size_t nread;
    int ret = rgw_read(fs, object_fh, 0 /* off */, 512 /* len */, &nread, sbuf,
		       RGW_READ_FLAG_NONE);
    ASSERT_EQ(ret, 0);
    buffer::list bl;
    bl.push_back(buffer::create_static(nread, sbuf));
    if (do_hexdump) {
      dout(15) << "";
      bl.hexdump(*_dout);
      *_dout << dendl;
    }
  }
}

TEST(LibRGW, STAT_OBJECT) {
  if (do_stat) {
    struct stat st;
    int ret = rgw_getattr(fs, object_fh, &st, RGW_GETATTR_FLAG_NONE);
    ASSERT_EQ(ret, 0);
    dout(15) << "rgw_getattr on " << object_name << " size = "
	     << st.st_size << dendl;
  }
}

TEST(LibRGW, WRITE_READ_VERIFY)
{
  if (do_bulk && do_put) {
    ZPageSet zp_set1{iovcnt}; // 1M random data in 16 64K pages
    struct iovec *iovs = zp_set1.get_iovs();

    /* read after write POSIX-style */
    size_t nbytes, off = 0;
    for (int ix = 0; ix < 16; ++ix, off += page_size) {
      struct iovec *iov = &iovs[ix];
      int ret = rgw_write(fs, object_fh, off, page_size, &nbytes,
			  iov->iov_base, RGW_WRITE_FLAG_NONE);
      ASSERT_EQ(ret, 0);
      ASSERT_EQ(nbytes, size_t(page_size));
    }
    zp_set1.reset_iovs();
  }
}

/* "functions that call alloca are not inlined"
 * --alexandre oliva
 * http://gcc.gnu.org/ml/gcc-help/2004-04/msg00158.html
 */
#define alloca_uio()				\
  do {\
    int uiosz = sizeof(rgw_uio) + iovcnt*sizeof(rgw_vio);		\
    uio = static_cast<rgw_uio*>(alloca(uiosz));				\
    memset(uio, 0, uiosz);						\
    uio->uio_vio = reinterpret_cast<rgw_vio*>(uio+sizeof(rgw_uio));	\
  } while (0);								\

TEST(LibRGW, WRITEV)
{
  if (do_writev) {
    rgw_uio* uio;
    struct iovec *iovs = zp_set1.get_iovs();
    alloca_uio();
    ASSERT_NE(uio, nullptr);

    for (int ix = 0; ix < iovcnt; ++ix) {
      struct iovec *iov = &iovs[ix];
      rgw_vio *vio = &(uio->uio_vio[ix]);
      vio->vio_base = iov->iov_base;
      vio->vio_len = iov->iov_len;
      vio->vio_u1 = iov; // private data
    }
    uio->uio_cnt = iovcnt;
    uio->uio_offset = iovcnt * page_size;

    int ret = rgw_writev(fs, object_fh, uio, RGW_WRITE_FLAG_NONE);
    ASSERT_EQ(ret, 0);
  }
}

TEST(LibRGW, READV)
{
  if (do_readv) {
    memset(uio, 0, sizeof(rgw_uio));
    uio->uio_offset = 0; // ok, it was already 0
    uio->uio_resid = UINT64_MAX;
    int ret = rgw_readv(fs, object_fh, uio, RGW_READ_FLAG_NONE);
    ASSERT_EQ(ret, 0);
    buffer::list bl;
    for (unsigned int ix = 0; ix < uio->uio_cnt; ++ix) {
      rgw_vio *vio = &(uio->uio_vio[ix]);
      bl.push_back(
	buffer::create_static(vio->vio_len,
			      static_cast<char*>(vio->vio_base)));
    }

    /* length check */
    ASSERT_EQ(uint32_t{bl.length()}, uint32_t{iovcnt*page_size});

    if (do_hexdump) {
      dout(15) << "";
      bl.hexdump(*_dout);
      *_dout << dendl;
    }
  }
}

TEST(LibRGW, READV_AFTER_WRITEV)
{
  /* checksum data */
  if (do_readv && do_writev && do_verify) {
    ASSERT_TRUE(zp_set1 == uio);
  }
}

TEST(LibRGW, DELETE_OBJECT) {
  if (do_delete) {
    int ret = rgw_unlink(fs, bucket_fh, object_name.c_str(),
			 RGW_UNLINK_FLAG_NONE);
    ASSERT_EQ(ret, 0);
  }
}

TEST(LibRGW, DELETE_BUCKET) {
  if (do_delete) {
    int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(),
			 RGW_UNLINK_FLAG_NONE);
    ASSERT_EQ(ret, 0);
  }
}

TEST(LibRGW, CLEANUP) {
  if (do_readv) {
    // release resources
    ASSERT_NE(uio->uio_rele, nullptr);
    if (uio->uio_rele) {
      uio->uio_rele(uio, RGW_UIO_NONE);
    }
  }
  int ret;
  if (object_open) {
    ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
    ASSERT_EQ(ret, 0);
  }
  if (object_fh) {
    ret = rgw_fh_rele(fs, object_fh, 0 /* flags */);
    ASSERT_EQ(ret, 0);
  }
  ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
  ASSERT_EQ(ret, 0);
}

TEST(LibRGW, UMOUNT) {
  if (! fs)
    return;

  int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
  ASSERT_EQ(ret, 0);
}

TEST(LibRGW, SHUTDOWN) {
  librgw_shutdown(rgw);
}

int main(int argc, char *argv[])
{
  char *v{nullptr};
  string val;
  vector<const char*> args;

  argv_to_vec(argc, const_cast<const char**>(argv), args);
  env_to_vec(args);

  v = getenv("AWS_ACCESS_KEY_ID");
  if (v) {
    access_key = v;
  }

  v = getenv("AWS_SECRET_ACCESS_KEY");
  if (v) {
    secret_key = v;
  }

  for (auto arg_iter = args.begin(); arg_iter != args.end();) {
    if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
			      (char*) nullptr)) {
      access_key = val;
    } else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
				     (char*) nullptr)) {
      secret_key = val;
    } else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
				     (char*) nullptr)) {
      uid = val;
    } else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
				     (char*) nullptr)) {
      bucket_name = val;
    } else if (ceph_argparse_flag(args, arg_iter, "--get",
					    (char*) nullptr)) {
      do_get = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--stat",
					    (char*) nullptr)) {
      do_stat = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--put",
					    (char*) nullptr)) {
      do_put = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--bulk",
					    (char*) nullptr)) {
      do_bulk = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--writev",
					    (char*) nullptr)) {
      do_writev = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--readv",
					    (char*) nullptr)) {
      do_readv = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--verify",
					    (char*) nullptr)) {
      do_verify = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--delete",
					    (char*) nullptr)) {
      do_delete = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--prelist",
					    (char*) nullptr)) {
      do_pre_list = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--create",
					    (char*) nullptr)) {
      do_create = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--hexdump",
					    (char*) nullptr)) {
      do_hexdump = true;
    } else {
      ++arg_iter;
    }
  }

  /* don't accidentally run as anonymous */
  if ((access_key == "") ||
      (secret_key == "")) {
    std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
    return EPERM;
  }

  saved_args.argc = argc;
  saved_args.argv = argv;

  ::testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}
Commit	Line	Data
7c673cae FG	1	// -- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t --
	2	// vim: ts=8 sw=2 smarttab
	3	/*
	4	* Ceph - scalable distributed file system
	5	*
	6	* Copyright (C) 2015 Red Hat, Inc.
	7	*
	8	* This is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License version 2.1, as published by the Free Software
	11	* Foundation. See file COPYING.
	12	*
	13	*/
	14
	15	#include <stdint.h>
	16	#include <tuple>
	17	#include <iostream>
	18	#include <vector>
	19	#include <map>
	20	#include <random>
	21	#include "xxhash.h"
	22
	23	#include "include/rados/librgw.h"
	24	#include "include/rados/rgw_file.h"
	25
	26	#include "gtest/gtest.h"
	27	#include "common/ceph_argparse.h"
	28	#include "common/debug.h"
7c673cae FG	29
	30	#define dout_context g_ceph_context
	31	#define dout_subsys ceph_subsys_rgw
	32
	33	namespace {
	34	librgw_t rgw = nullptr;
	35	string uid("testuser");
	36	string access_key("");
	37	string secret_key("");
	38	struct rgw_fs *fs = nullptr;
	39
	40	bool do_pre_list = false;
	41	bool do_put = false;
	42	bool do_bulk = false;
	43	bool do_writev = false;
	44	bool do_readv = false;
	45	bool do_verify = false;
	46	bool do_get = false;
f67539c2	47	bool do_create = false;
7c673cae FG	48	bool do_delete = false;
	49	bool do_stat = false; // stat objects (not buckets)
	50	bool do_hexdump = false;
	51
	52	bool object_open = false;
	53
f67539c2 TL	54	uint32_t owner_uid = 867;
	55	uint32_t owner_gid = 5309;
	56	uint32_t create_mask = RGW_SETATTR_UID \| RGW_SETATTR_GID \| RGW_SETATTR_MODE;
	57
	58	string bucket_name = "blastoff";
7c673cae FG	59	string object_name = "jocaml";
	60
	61	struct rgw_file_handle *bucket_fh = nullptr;
	62	struct rgw_file_handle *object_fh = nullptr;
	63
	64	typedef std::tuple<string,uint64_t, struct rgw_file_handle*> fid_type;
	65	std::vector<fid_type> fids;
	66
	67	std::uniform_int_distribution<uint8_t> uint_dist;
	68	std::mt19937 rng;
	69
	70	constexpr int iovcnt = 16;
	71	constexpr int page_size = 65536;
	72	constexpr int seed = 8675309;
	73
	74	struct ZPage
	75	{
	76	char data[page_size];
	77	uint64_t cksum;
	78	}; /* ZPage */
	79
	80	struct ZPageSet
	81	{
	82	std::vector<ZPage*> pages;
	83	struct iovec* iovs;
	84
11fdf7f2	85	explicit ZPageSet(int n) {
7c673cae FG	86	pages.reserve(n);
	87	iovs = (struct iovec*) calloc(n, sizeof(struct iovec));
	88	for (int page_ix = 0; page_ix < n; ++page_ix) {
	89	ZPage* p = new ZPage();
	90	for (int data_ix = 0; data_ix < page_size; ++data_ix) {
	91	p->data[data_ix] = uint_dist(rng);
	92	} // data_ix
	93	p->cksum = XXH64(p->data, page_size, seed);
	94	pages.emplace_back(p);
	95	// and iovs
	96	struct iovec* iov = &iovs[page_ix];
	97	iov->iov_base = p->data;
	98	iov->iov_len = page_size;
	99	} // page_ix
	100	}
	101
	102	int size() { return pages.size(); }
	103
	104	struct iovec* get_iovs() { return iovs; }
	105
	106	bool operator==(const ZPageSet& rhs) {
	107	int n = size();
	108	for (int page_ix = 0; page_ix < n; ++page_ix) {
	109	ZPage* p1 = pages[page_ix];
	110	ZPage* p2 = rhs.pages[page_ix];
	111	if (p1->cksum != p2->cksum)
	112	return false;
	113	}
	114	return true;
	115	}
	116
	117	bool operator==(const rgw_uio* uio) {
	118	uint64_t cksum;
	119	int vix = 0, off = 0;
	120	rgw_vio* vio = &uio->uio_vio[vix];
	121	int vio_len = vio->vio_len;
	122	char *data;
	123
	124	for (int ix = 0; ix < iovcnt; ++ix) {
	125	ZPage* p1 = pages[ix];
	126	data = static_cast<char*>(vio->vio_base) + off;
	127	cksum = XXH64(data, page_size, seed);
	128
	129	if (p1->cksum != cksum) {
	130	int r = memcmp(data, p1->data, page_size);
	131	std::cout << "problem at ix " << ix << " r " << r<< std::endl;
	132	return false;
	133	}
	134
	135	off += page_size;
	136	if (off >= vio_len) {
	137	vio = &uio->uio_vio[++vix];
	138	vio_len = vio->vio_len;
	139	off = 0;
	140	}
	141	}
	142	return true;
	143	}
	144
	145	void cksum() {
	146	int n = size();
	147	for (int page_ix = 0; page_ix < n; ++page_ix) {
	148	ZPage* p = pages[page_ix];
	149	p->cksum = XXH64(p->data, page_size, seed);
150	}
151	}
152
153	void reset_iovs() { // VOP_READ and VOP_WRITE update
154	int n = size();
155	for (int page_ix = 0; page_ix < n; ++page_ix) {
156	ZPage* p = pages[page_ix];
157	struct iovec* iov = &iovs[page_ix];
158	iov->iov_base = p->data;
159	iov->iov_len = page_size;
160	}
161	}
162
163	~ZPageSet() {
164	for (unsigned int ix = 0; ix < pages.size(); ++ix)
165	delete pages[ix];
166	free(iovs);
167	}
168	}; /* ZPageSet */
169
170	rgw_uio uio[1];
171	ZPageSet zp_set1{iovcnt}; // 1M random data in 16 64K pages
172
173	struct {
174	int argc;
175	char **argv;
176	} saved_args;
177	}
178
179	TEST(LibRGW, INIT) {
180	int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
181	ASSERT_EQ(ret, 0);
182	ASSERT_NE(rgw, nullptr);
183	}
184
185	TEST(LibRGW, MOUNT) {
3efd9988 FG	186	int ret = rgw_mount2(rgw, uid.c_str(), access_key.c_str(), secret_key.c_str(),
3efd9988 FG	187	"/", &fs, RGW_MOUNT_FLAG_NONE);
7c673cae FG	188	ASSERT_EQ(ret, 0);
	189	ASSERT_NE(fs, nullptr);
	190	}
	191
f67539c2 TL	192	TEST(LibRGW, CREATE_BUCKET) {
	193	if (do_create) {
	194	struct stat st;
	195	struct rgw_file_handle *fh;
	196
	197	st.st_uid = owner_uid;
	198	st.st_gid = owner_gid;
	199	st.st_mode = 755;
	200
	201	int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
	202	&fh, RGW_MKDIR_FLAG_NONE);
	203	ASSERT_EQ(ret, 0);
	204	}
	205	}
	206
7c673cae FG	207	TEST(LibRGW, LOOKUP_BUCKET) {
7c673cae FG	208	int ret = rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
eafe8130	209	nullptr, 0, RGW_LOOKUP_FLAG_NONE);
7c673cae FG	210	ASSERT_EQ(ret, 0);
	211	}
	212
	213	extern "C" {
	214	static bool r2_cb(const char* name, void *arg, uint64_t offset,
eafe8130	215	struct stat *st, uint32_t st_mask,
7c673cae FG	216	uint32_t flags) {
	217	// don't need arg--it would point to fids
	218	fids.push_back(fid_type(name, offset, nullptr));
	219	return true; /* XXX ? */
	220	}
	221	}
	222
	223	TEST(LibRGW, LIST_OBJECTS) {
	224	if (do_pre_list) {
	225	/* list objects via readdir, bucketwise */
	226	using std::get;
	227
	228	ldout(g_ceph_context, 0) << __func__ << " readdir on bucket "
	229	<< bucket_name << dendl;
	230	bool eof = false;
	231	uint64_t offset = 0;
	232	int ret = rgw_readdir(fs, bucket_fh, &offset, r2_cb, &fids,
	233	&eof, RGW_READDIR_FLAG_NONE);
	234	for (auto& fid : fids) {
	235	std::cout << "fname: " << get<0>(fid) << " fid: " << get<1>(fid)
	236	<< std::endl;
	237	}
	238	ASSERT_EQ(ret, 0);
	239	}
	240	}
	241
	242	TEST(LibRGW, LOOKUP_OBJECT) {
	243	if (do_get \|\| do_stat \|\| do_put \|\| do_bulk \|\| do_readv \|\| do_writev) {
	244	int ret = rgw_lookup(fs, bucket_fh, object_name.c_str(), &object_fh,
eafe8130	245	nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
7c673cae FG	246	ASSERT_EQ(ret, 0);
	247	}
	248	}
	249
	250	TEST(LibRGW, OBJ_OPEN) {
	251	if (do_get \|\| do_put \|\| do_readv \|\| do_writev) {
	252	int ret = rgw_open(fs, object_fh, 0 /* posix flags /, 0 / flags */);
	253	ASSERT_EQ(ret, 0);
	254	object_open = true;
	255	}
	256	}
	257
	258	TEST(LibRGW, PUT_OBJECT) {
	259	if (do_put) {
	260	size_t nbytes;
	261	string data = "hi mom"; // fix this
	262	int ret = rgw_write(fs, object_fh, 0, data.length(), &nbytes,
	263	(void*) data.c_str(), RGW_WRITE_FLAG_NONE);
	264	ASSERT_EQ(ret, 0);
	265	ASSERT_EQ(nbytes, data.length());
f67539c2 TL	266	/* commit write transaction */
	267	ret = rgw_close(fs, object_fh, 0 /* flags */);
	268	ASSERT_EQ(ret, 0);
7c673cae FG	269	}
	270	}
	271
	272	TEST(LibRGW, GET_OBJECT) {
	273	if (do_get) {
	274	char sbuf[512];
	275	memset(sbuf, 0, 512);
	276	size_t nread;
	277	int ret = rgw_read(fs, object_fh, 0 /* off /, 512 / len */, &nread, sbuf,
	278	RGW_READ_FLAG_NONE);
	279	ASSERT_EQ(ret, 0);
	280	buffer::list bl;
	281	bl.push_back(buffer::create_static(nread, sbuf));
	282	if (do_hexdump) {
	283	dout(15) << "";
	284	bl.hexdump(*_dout);
	285	*_dout << dendl;
	286	}
	287	}
	288	}
	289
	290	TEST(LibRGW, STAT_OBJECT) {
	291	if (do_stat) {
	292	struct stat st;
	293	int ret = rgw_getattr(fs, object_fh, &st, RGW_GETATTR_FLAG_NONE);
	294	ASSERT_EQ(ret, 0);
	295	dout(15) << "rgw_getattr on " << object_name << " size = "
	296	<< st.st_size << dendl;
	297	}
	298	}
	299
	300	TEST(LibRGW, WRITE_READ_VERIFY)
	301	{
	302	if (do_bulk && do_put) {
	303	ZPageSet zp_set1{iovcnt}; // 1M random data in 16 64K pages
	304	struct iovec *iovs = zp_set1.get_iovs();
	305
	306	/* read after write POSIX-style */
	307	size_t nbytes, off = 0;
	308	for (int ix = 0; ix < 16; ++ix, off += page_size) {
	309	struct iovec *iov = &iovs[ix];
	310	int ret = rgw_write(fs, object_fh, off, page_size, &nbytes,
	311	iov->iov_base, RGW_WRITE_FLAG_NONE);
	312	ASSERT_EQ(ret, 0);
	313	ASSERT_EQ(nbytes, size_t(page_size));
	314	}
	315	zp_set1.reset_iovs();
	316	}
	317	}
	318
	319	/* "functions that call alloca are not inlined"
	320	* --alexandre oliva
	321	* http://gcc.gnu.org/ml/gcc-help/2004-04/msg00158.html
	322	*/
	323	#define alloca_uio() \
	324	do {\
	325	int uiosz = sizeof(rgw_uio) + iovcnt*sizeof(rgw_vio); \
	326	uio = static_cast<rgw_uio*>(alloca(uiosz)); \
	327	memset(uio, 0, uiosz); \
	328	uio->uio_vio = reinterpret_cast<rgw_vio*>(uio+sizeof(rgw_uio)); \
	329	} while (0); \
	330
	331	TEST(LibRGW, WRITEV)
	332	{
333	if (do_writev) {
334	rgw_uio* uio;
335	struct iovec *iovs = zp_set1.get_iovs();
336	alloca_uio();
337	ASSERT_NE(uio, nullptr);
338
339	for (int ix = 0; ix < iovcnt; ++ix) {
340	struct iovec *iov = &iovs[ix];
341	rgw_vio *vio = &(uio->uio_vio[ix]);
342	vio->vio_base = iov->iov_base;
343	vio->vio_len = iov->iov_len;
344	vio->vio_u1 = iov; // private data
345	}
346	uio->uio_cnt = iovcnt;
347	uio->uio_offset = iovcnt * page_size;
348
349	int ret = rgw_writev(fs, object_fh, uio, RGW_WRITE_FLAG_NONE);
350	ASSERT_EQ(ret, 0);
351	}
352	}
353
354	TEST(LibRGW, READV)
355	{
356	if (do_readv) {
357	memset(uio, 0, sizeof(rgw_uio));
358	uio->uio_offset = 0; // ok, it was already 0
359	uio->uio_resid = UINT64_MAX;
360	int ret = rgw_readv(fs, object_fh, uio, RGW_READ_FLAG_NONE);
361	ASSERT_EQ(ret, 0);
362	buffer::list bl;
363	for (unsigned int ix = 0; ix < uio->uio_cnt; ++ix) {
364	rgw_vio *vio = &(uio->uio_vio[ix]);
365	bl.push_back(
366	buffer::create_static(vio->vio_len,
367	static_cast<char*>(vio->vio_base)));
368	}
369
370	/* length check */
371	ASSERT_EQ(uint32_t{bl.length()}, uint32_t{iovcnt*page_size});
372
373	if (do_hexdump) {
374	dout(15) << "";
375	bl.hexdump(*_dout);
376	*_dout << dendl;
377	}
378	}
379	}
380
381	TEST(LibRGW, READV_AFTER_WRITEV)
382	{
383	/* checksum data */
384	if (do_readv && do_writev && do_verify) {
385	ASSERT_TRUE(zp_set1 == uio);
386	}
387	}
388
389	TEST(LibRGW, DELETE_OBJECT) {
390	if (do_delete) {
391	int ret = rgw_unlink(fs, bucket_fh, object_name.c_str(),
392	RGW_UNLINK_FLAG_NONE);
393	ASSERT_EQ(ret, 0);
394	}
395	}
396
f67539c2 TL	397	TEST(LibRGW, DELETE_BUCKET) {
	398	if (do_delete) {
	399	int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(),
	400	RGW_UNLINK_FLAG_NONE);
	401	ASSERT_EQ(ret, 0);
	402	}
	403	}
	404
7c673cae FG	405	TEST(LibRGW, CLEANUP) {
	406	if (do_readv) {
	407	// release resources
	408	ASSERT_NE(uio->uio_rele, nullptr);
	409	if (uio->uio_rele) {
	410	uio->uio_rele(uio, RGW_UIO_NONE);
	411	}
	412	}
	413	int ret;
	414	if (object_open) {
	415	ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
	416	ASSERT_EQ(ret, 0);
	417	}
	418	if (object_fh) {
	419	ret = rgw_fh_rele(fs, object_fh, 0 /* flags */);
	420	ASSERT_EQ(ret, 0);
	421	}
	422	ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
	423	ASSERT_EQ(ret, 0);
	424	}
	425
	426	TEST(LibRGW, UMOUNT) {
	427	if (! fs)
	428	return;
	429
	430	int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
	431	ASSERT_EQ(ret, 0);
	432	}
	433
	434	TEST(LibRGW, SHUTDOWN) {
	435	librgw_shutdown(rgw);
	436	}
	437
	438	int main(int argc, char *argv[])
	439	{
	440	char *v{nullptr};
	441	string val;
	442	vector<const char*> args;
	443
	444	argv_to_vec(argc, const_cast<const char**>(argv), args);
	445	env_to_vec(args);
	446
	447	v = getenv("AWS_ACCESS_KEY_ID");
	448	if (v) {
	449	access_key = v;
	450	}
	451
	452	v = getenv("AWS_SECRET_ACCESS_KEY");
	453	if (v) {
	454	secret_key = v;
	455	}
	456
	457	for (auto arg_iter = args.begin(); arg_iter != args.end();) {
	458	if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
	459	(char*) nullptr)) {
	460	access_key = val;
	461	} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
	462	(char*) nullptr)) {
	463	secret_key = val;
	464	} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
	465	(char*) nullptr)) {
	466	uid = val;
	467	} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
	468	(char*) nullptr)) {
469	bucket_name = val;
470	} else if (ceph_argparse_flag(args, arg_iter, "--get",
471	(char*) nullptr)) {
472	do_get = true;
473	} else if (ceph_argparse_flag(args, arg_iter, "--stat",
474	(char*) nullptr)) {
475	do_stat = true;
476	} else if (ceph_argparse_flag(args, arg_iter, "--put",
477	(char*) nullptr)) {
478	do_put = true;
479	} else if (ceph_argparse_flag(args, arg_iter, "--bulk",
480	(char*) nullptr)) {
481	do_bulk = true;
482	} else if (ceph_argparse_flag(args, arg_iter, "--writev",
483	(char*) nullptr)) {
484	do_writev = true;
485	} else if (ceph_argparse_flag(args, arg_iter, "--readv",
486	(char*) nullptr)) {
487	do_readv = true;
488	} else if (ceph_argparse_flag(args, arg_iter, "--verify",
489	(char*) nullptr)) {
490	do_verify = true;
491	} else if (ceph_argparse_flag(args, arg_iter, "--delete",
492	(char*) nullptr)) {
493	do_delete = true;
494	} else if (ceph_argparse_flag(args, arg_iter, "--prelist",
495	(char*) nullptr)) {
496	do_pre_list = true;
f67539c2 TL	497	} else if (ceph_argparse_flag(args, arg_iter, "--create",
	498	(char*) nullptr)) {
	499	do_create = true;
7c673cae FG	500	} else if (ceph_argparse_flag(args, arg_iter, "--hexdump",
	501	(char*) nullptr)) {
	502	do_hexdump = true;
	503	} else {
	504	++arg_iter;
	505	}
	506	}
	507
11fdf7f2	508	/* don't accidentally run as anonymous */
7c673cae FG	509	if ((access_key == "") \|\|
	510	(secret_key == "")) {
	511	std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
	512	return EPERM;
	513	}
	514
	515	saved_args.argc = argc;
	516	saved_args.argv = argv;
	517
	518	::testing::InitGoogleTest(&argc, argv);
	519	return RUN_ALL_TESTS();
	520	}