[ceph.git] / ceph / src / test / librgw_file_aw.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

using namespace std;

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

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

  bool do_create = false;
  bool do_delete = false;
  bool do_large = false;
  bool do_verify = false;
  bool do_hexdump = false;

  string bucket_name = "sorrydave";
  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 = 4;
  constexpr int page_size = /* 65536 */ 4 * 1024*1024;
  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 */

  ZPageSet zp_set1{iovcnt}; // random data
  ZPageSet zp_set2{iovcnt}; // random data in 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, userid.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);
}

TEST(LibRGW, LOOKUP_OBJECT) {
  int ret = rgw_lookup(fs, bucket_fh, object_name.c_str(), &object_fh,
		       nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
  ASSERT_EQ(ret, 0);
}

#if 0
TEST(LibRGW, OPEN1) {
  int ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
  ASSERT_EQ(ret, 0);
}

TEST(LibRGW, PUT_OBJECT) {
  size_t nbytes;
  struct iovec *iovs = zp_set1.get_iovs();
  off_t offset = 0;
  for (int ix : {0, 1}) {
    struct iovec *iov = &iovs[ix];
    // quick check
    sprintf(static_cast<char*>(iov->iov_base), "::hi mom (%d)", ix);
    iov->iov_len = 14;
    int ret = rgw_write(fs, object_fh, offset, iov->iov_len, &nbytes,
			iov->iov_base, RGW_WRITE_FLAG_NONE);
    offset += iov->iov_len;
    ASSERT_EQ(ret, 0);
    ASSERT_EQ(nbytes, iov->iov_len);
  }
}

TEST(LibRGW, CLOSE1) {
  int ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
  ASSERT_EQ(ret, 0);
}

TEST(LibRGW, OPEN2) {
  int ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
  ASSERT_EQ(ret, 0);
}

TEST(LibRGW, GET_OBJECT) {
  size_t nread;
  off_t offset = 0;
  struct iovec *iovs = zp_set1.get_iovs();
  for (int ix : {2 , 3}) {
    struct iovec *iov = &iovs[ix];
    int ret = rgw_read(fs, object_fh, offset, iovs[ix-2].iov_len, &nread,
		       iov->iov_base, RGW_READ_FLAG_NONE);
    iov->iov_len = nread;
    offset += iov->iov_len;
    ASSERT_EQ(ret, 0);
    ASSERT_EQ(nread, iovs[ix-2].iov_len);
    std::cout << "read: " << static_cast<char*>(iov->iov_base) << std::endl;
  }
}

TEST(LibRGW, CLOSE2) {
  int ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
  ASSERT_EQ(ret, 0);
}
#endif

TEST (LibRGW, LARGE1) {
  if (do_large) {
    int ret;

    ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
    ASSERT_EQ(ret, 0);

    size_t nbytes;
    struct iovec *iovs = zp_set1.get_iovs();
    off_t offset = 0;

    for (int ix = 0; ix < iovcnt; ++ix) {
      struct iovec *iov = &iovs[ix];
      // write iov->iov_len
      ret = rgw_write(fs, object_fh, offset, iov->iov_len, &nbytes,
		      iov->iov_base, RGW_WRITE_FLAG_NONE);
      offset += iov->iov_len;
      ASSERT_EQ(ret, 0);
      ASSERT_EQ(nbytes, iov->iov_len);
    }

    ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
    ASSERT_EQ(ret, 0);
  } /* do_large */
}

TEST (LibRGW, LARGE2) {
  if (do_large) {
    int ret;
    if (do_verify) {
      ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
      ASSERT_EQ(ret, 0);

      size_t nread;
      off_t offset2 = 0;
      struct iovec *iovs2 = zp_set2.get_iovs();
      for (int ix = 0; ix < iovcnt; ++ix) {
	struct iovec *iov2 = &iovs2[ix];
	ret = rgw_read(fs, object_fh, offset2, iov2->iov_len, &nread,
		       iov2->iov_base, RGW_READ_FLAG_NONE);
	iov2->iov_len = nread;
	offset2 += iov2->iov_len;
	ASSERT_EQ(ret, 0);
      }
      zp_set1.cksum();
      zp_set2.cksum();
      ASSERT_TRUE(zp_set1 == zp_set2);

      ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
      ASSERT_EQ(ret, 0);
    }
  } /* do_large */
}

TEST(LibRGW, STAT_OBJECT) {
  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, 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) {
  int ret;
  if (object_fh) {
    ret = rgw_fh_rele(fs, object_fh, RGW_FH_RELE_FLAG_NONE);
    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[])
{
  auto args = argv_to_vec(argc, argv);
  env_to_vec(args);

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

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

  string val;

  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, "--userid",
				     (char*) nullptr)) {
      userid = val;
    } else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
				     (char*) nullptr)) {
      bucket_name = val;
    } else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
				     (char*) nullptr)) {
      owner_uid = std::stoi(val);
    } else if (ceph_argparse_witharg(args, arg_iter, &val, "--gid",
				     (char*) nullptr)) {
      owner_gid = std::stoi(val);
    } else if (ceph_argparse_flag(args, arg_iter, "--verify",
					    (char*) nullptr)) {
      do_verify = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--create",
					    (char*) nullptr)) {
      do_create = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--delete",
					    (char*) nullptr)) {
      do_delete = true;
    } else if (ceph_argparse_flag(args, arg_iter, "--large",
					    (char*) nullptr)) {
      do_large = 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
20effc67 TL	33	using namespace std;
20effc67 TL	34
7c673cae FG	35	namespace {
	36	librgw_t rgw = nullptr;
	37	string userid("testuser");
	38	string access_key("");
	39	string secret_key("");
	40	struct rgw_fs *fs = nullptr;
	41
	42	uint32_t owner_uid = 867;
	43	uint32_t owner_gid = 5309;
	44	uint32_t create_mask = RGW_SETATTR_UID \| RGW_SETATTR_GID \| RGW_SETATTR_MODE;
	45
	46	bool do_create = false;
	47	bool do_delete = false;
224ce89b	48	bool do_large = false;
7c673cae FG	49	bool do_verify = false;
	50	bool do_hexdump = false;
	51
f67539c2	52	string bucket_name = "sorrydave";
7c673cae FG	53	string object_name = "jocaml";
	54
	55	struct rgw_file_handle *bucket_fh = nullptr;
	56	struct rgw_file_handle *object_fh = nullptr;
	57
	58	typedef std::tuple<string,uint64_t, struct rgw_file_handle*> fid_type;
	59	std::vector<fid_type> fids;
	60
	61	std::uniform_int_distribution<uint8_t> uint_dist;
	62	std::mt19937 rng;
	63
224ce89b WB	64	constexpr int iovcnt = 4;
224ce89b WB	65	constexpr int page_size = /* 65536 / 4 1024*1024;
7c673cae FG	66	constexpr int seed = 8675309;
	67
	68	struct ZPage
	69	{
	70	char data[page_size];
	71	uint64_t cksum;
	72	}; /* ZPage */
	73
	74	struct ZPageSet
	75	{
	76	std::vector<ZPage*> pages;
	77	struct iovec* iovs;
	78
11fdf7f2	79	explicit ZPageSet(int n) {
7c673cae FG	80	pages.reserve(n);
	81	iovs = (struct iovec*) calloc(n, sizeof(struct iovec));
	82	for (int page_ix = 0; page_ix < n; ++page_ix) {
	83	ZPage* p = new ZPage();
	84	for (int data_ix = 0; data_ix < page_size; ++data_ix) {
	85	p->data[data_ix] = uint_dist(rng);
	86	} // data_ix
	87	p->cksum = XXH64(p->data, page_size, seed);
	88	pages.emplace_back(p);
	89	// and iovs
	90	struct iovec* iov = &iovs[page_ix];
	91	iov->iov_base = p->data;
	92	iov->iov_len = page_size;
	93	} // page_ix
	94	}
	95
	96	int size() { return pages.size(); }
	97
	98	struct iovec* get_iovs() { return iovs; }
	99
	100	bool operator==(const ZPageSet& rhs) {
	101	int n = size();
	102	for (int page_ix = 0; page_ix < n; ++page_ix) {
	103	ZPage* p1 = pages[page_ix];
	104	ZPage* p2 = rhs.pages[page_ix];
	105	if (p1->cksum != p2->cksum)
	106	return false;
	107	}
	108	return true;
	109	}
	110
	111	bool operator==(const rgw_uio* uio) {
	112	uint64_t cksum;
	113	int vix = 0, off = 0;
	114	rgw_vio* vio = &uio->uio_vio[vix];
	115	int vio_len = vio->vio_len;
	116	char *data;
	117
	118	for (int ix = 0; ix < iovcnt; ++ix) {
	119	ZPage* p1 = pages[ix];
	120	data = static_cast<char*>(vio->vio_base) + off;
	121	cksum = XXH64(data, page_size, seed);
	122
	123	if (p1->cksum != cksum) {
	124	int r = memcmp(data, p1->data, page_size);
	125	std::cout << "problem at ix " << ix << " r " << r<< std::endl;
	126	return false;
	127	}
	128
	129	off += page_size;
	130	if (off >= vio_len) {
	131	vio = &uio->uio_vio[++vix];
	132	vio_len = vio->vio_len;
	133	off = 0;
	134	}
	135	}
	136	return true;
	137	}
	138
	139	void cksum() {
	140	int n = size();
	141	for (int page_ix = 0; page_ix < n; ++page_ix) {
	142	ZPage* p = pages[page_ix];
	143	p->cksum = XXH64(p->data, page_size, seed);
144	}
145	}
146
147	void reset_iovs() { // VOP_READ and VOP_WRITE update
148	int n = size();
149	for (int page_ix = 0; page_ix < n; ++page_ix) {
150	ZPage* p = pages[page_ix];
151	struct iovec* iov = &iovs[page_ix];
152	iov->iov_base = p->data;
153	iov->iov_len = page_size;
154	}
155	}
156
157	~ZPageSet() {
158	for (unsigned int ix = 0; ix < pages.size(); ++ix)
159	delete pages[ix];
160	free(iovs);
161	}
162	}; /* ZPageSet */
163
224ce89b WB	164	ZPageSet zp_set1{iovcnt}; // random data
224ce89b WB	165	ZPageSet zp_set2{iovcnt}; // random data in 64K pages
7c673cae FG	166
	167	struct {
	168	int argc;
	169	char **argv;
	170	} saved_args;
	171	}
	172
	173	TEST(LibRGW, INIT) {
	174	int ret = librgw_create(&rgw, saved_args.argc, saved_args.argv);
	175	ASSERT_EQ(ret, 0);
	176	ASSERT_NE(rgw, nullptr);
	177	}
	178
	179	TEST(LibRGW, MOUNT) {
3efd9988 FG	180	int ret = rgw_mount2(rgw, userid.c_str(), access_key.c_str(),
3efd9988 FG	181	secret_key.c_str(), "/", &fs, RGW_MOUNT_FLAG_NONE);
7c673cae FG	182	ASSERT_EQ(ret, 0);
	183	ASSERT_NE(fs, nullptr);
	184	}
	185
	186	TEST(LibRGW, CREATE_BUCKET) {
	187	if (do_create) {
	188	struct stat st;
	189	struct rgw_file_handle *fh;
	190
	191	st.st_uid = owner_uid;
	192	st.st_gid = owner_gid;
	193	st.st_mode = 755;
	194
	195	int ret = rgw_mkdir(fs, fs->root_fh, bucket_name.c_str(), &st, create_mask,
	196	&fh, RGW_MKDIR_FLAG_NONE);
	197	ASSERT_EQ(ret, 0);
	198	}
	199	}
	200
	201	TEST(LibRGW, LOOKUP_BUCKET) {
	202	int ret = rgw_lookup(fs, fs->root_fh, bucket_name.c_str(), &bucket_fh,
eafe8130	203	nullptr, 0, RGW_LOOKUP_FLAG_NONE);
7c673cae FG	204	ASSERT_EQ(ret, 0);
	205	}
	206
	207	TEST(LibRGW, LOOKUP_OBJECT) {
	208	int ret = rgw_lookup(fs, bucket_fh, object_name.c_str(), &object_fh,
eafe8130	209	nullptr, 0, RGW_LOOKUP_FLAG_CREATE);
7c673cae FG	210	ASSERT_EQ(ret, 0);
	211	}
	212
224ce89b	213	#if 0
7c673cae FG	214	TEST(LibRGW, OPEN1) {
	215	int ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
	216	ASSERT_EQ(ret, 0);
	217	}
	218
	219	TEST(LibRGW, PUT_OBJECT) {
	220	size_t nbytes;
	221	struct iovec *iovs = zp_set1.get_iovs();
	222	off_t offset = 0;
	223	for (int ix : {0, 1}) {
	224	struct iovec *iov = &iovs[ix];
	225	// quick check
	226	sprintf(static_cast<char*>(iov->iov_base), "::hi mom (%d)", ix);
	227	iov->iov_len = 14;
	228	int ret = rgw_write(fs, object_fh, offset, iov->iov_len, &nbytes,
	229	iov->iov_base, RGW_WRITE_FLAG_NONE);
	230	offset += iov->iov_len;
	231	ASSERT_EQ(ret, 0);
	232	ASSERT_EQ(nbytes, iov->iov_len);
	233	}
	234	}
	235
	236	TEST(LibRGW, CLOSE1) {
	237	int ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
	238	ASSERT_EQ(ret, 0);
	239	}
	240
	241	TEST(LibRGW, OPEN2) {
	242	int ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
	243	ASSERT_EQ(ret, 0);
	244	}
	245
	246	TEST(LibRGW, GET_OBJECT) {
	247	size_t nread;
	248	off_t offset = 0;
	249	struct iovec *iovs = zp_set1.get_iovs();
	250	for (int ix : {2 , 3}) {
	251	struct iovec *iov = &iovs[ix];
	252	int ret = rgw_read(fs, object_fh, offset, iovs[ix-2].iov_len, &nread,
	253	iov->iov_base, RGW_READ_FLAG_NONE);
	254	iov->iov_len = nread;
	255	offset += iov->iov_len;
	256	ASSERT_EQ(ret, 0);
	257	ASSERT_EQ(nread, iovs[ix-2].iov_len);
	258	std::cout << "read: " << static_cast<char*>(iov->iov_base) << std::endl;
	259	}
	260	}
	261
	262	TEST(LibRGW, CLOSE2) {
	263	int ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
	264	ASSERT_EQ(ret, 0);
	265	}
224ce89b WB	266	#endif
	267
	268	TEST (LibRGW, LARGE1) {
	269	if (do_large) {
	270	int ret;
	271
	272	ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
	273	ASSERT_EQ(ret, 0);
	274
	275	size_t nbytes;
	276	struct iovec *iovs = zp_set1.get_iovs();
	277	off_t offset = 0;
	278
	279	for (int ix = 0; ix < iovcnt; ++ix) {
	280	struct iovec *iov = &iovs[ix];
	281	// write iov->iov_len
	282	ret = rgw_write(fs, object_fh, offset, iov->iov_len, &nbytes,
	283	iov->iov_base, RGW_WRITE_FLAG_NONE);
	284	offset += iov->iov_len;
	285	ASSERT_EQ(ret, 0);
	286	ASSERT_EQ(nbytes, iov->iov_len);
	287	}
	288
	289	ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
	290	ASSERT_EQ(ret, 0);
	291	} /* do_large */
	292	}
	293
	294	TEST (LibRGW, LARGE2) {
	295	if (do_large) {
	296	int ret;
	297	if (do_verify) {
	298	ret = rgw_open(fs, object_fh, 0 /* posix flags */, RGW_OPEN_FLAG_NONE);
	299	ASSERT_EQ(ret, 0);
	300
	301	size_t nread;
	302	off_t offset2 = 0;
	303	struct iovec *iovs2 = zp_set2.get_iovs();
	304	for (int ix = 0; ix < iovcnt; ++ix) {
	305	struct iovec *iov2 = &iovs2[ix];
	306	ret = rgw_read(fs, object_fh, offset2, iov2->iov_len, &nread,
	307	iov2->iov_base, RGW_READ_FLAG_NONE);
	308	iov2->iov_len = nread;
	309	offset2 += iov2->iov_len;
	310	ASSERT_EQ(ret, 0);
	311	}
	312	zp_set1.cksum();
	313	zp_set2.cksum();
	314	ASSERT_TRUE(zp_set1 == zp_set2);
	315
	316	ret = rgw_close(fs, object_fh, RGW_CLOSE_FLAG_NONE);
	317	ASSERT_EQ(ret, 0);
	318	}
	319	} /* do_large */
	320	}
7c673cae FG	321
	322	TEST(LibRGW, STAT_OBJECT) {
	323	struct stat st;
	324	int ret = rgw_getattr(fs, object_fh, &st, RGW_GETATTR_FLAG_NONE);
	325	ASSERT_EQ(ret, 0);
	326	dout(15) << "rgw_getattr on " << object_name << " size = "
	327	<< st.st_size << dendl;
	328	}
	329
	330	TEST(LibRGW, DELETE_OBJECT) {
	331	if (do_delete) {
	332	int ret = rgw_unlink(fs, bucket_fh, object_name.c_str(),
	333	RGW_UNLINK_FLAG_NONE);
	334	ASSERT_EQ(ret, 0);
	335	}
	336	}
	337
f67539c2 TL	338	TEST(LibRGW, DELETE_BUCKET) {
	339	if (do_delete) {
	340	int ret = rgw_unlink(fs, fs->root_fh, bucket_name.c_str(),
	341	RGW_UNLINK_FLAG_NONE);
	342	ASSERT_EQ(ret, 0);
	343	}
	344	}
	345
7c673cae FG	346	TEST(LibRGW, CLEANUP) {
	347	int ret;
	348	if (object_fh) {
	349	ret = rgw_fh_rele(fs, object_fh, RGW_FH_RELE_FLAG_NONE);
	350	ASSERT_EQ(ret, 0);
	351	}
	352	ret = rgw_fh_rele(fs, bucket_fh, 0 /* flags */);
	353	ASSERT_EQ(ret, 0);
	354	}
	355
	356	TEST(LibRGW, UMOUNT) {
	357	if (! fs)
	358	return;
	359
	360	int ret = rgw_umount(fs, RGW_UMOUNT_FLAG_NONE);
	361	ASSERT_EQ(ret, 0);
	362	}
	363
	364	TEST(LibRGW, SHUTDOWN) {
	365	librgw_shutdown(rgw);
	366	}
	367
	368	int main(int argc, char *argv[])
	369	{
20effc67	370	auto args = argv_to_vec(argc, argv);
7c673cae FG	371	env_to_vec(args);
7c673cae FG	372
20effc67	373	char* v = getenv("AWS_ACCESS_KEY_ID");
7c673cae FG	374	if (v) {
	375	access_key = v;
	376	}
	377
	378	v = getenv("AWS_SECRET_ACCESS_KEY");
	379	if (v) {
	380	secret_key = v;
	381	}
	382
20effc67 TL	383	string val;
20effc67 TL	384
7c673cae FG	385	for (auto arg_iter = args.begin(); arg_iter != args.end();) {
	386	if (ceph_argparse_witharg(args, arg_iter, &val, "--access",
	387	(char*) nullptr)) {
	388	access_key = val;
	389	} else if (ceph_argparse_witharg(args, arg_iter, &val, "--secret",
	390	(char*) nullptr)) {
	391	secret_key = val;
	392	} else if (ceph_argparse_witharg(args, arg_iter, &val, "--userid",
	393	(char*) nullptr)) {
	394	userid = val;
	395	} else if (ceph_argparse_witharg(args, arg_iter, &val, "--bn",
	396	(char*) nullptr)) {
	397	bucket_name = val;
	398	} else if (ceph_argparse_witharg(args, arg_iter, &val, "--uid",
	399	(char*) nullptr)) {
	400	owner_uid = std::stoi(val);
	401	} else if (ceph_argparse_witharg(args, arg_iter, &val, "--gid",
	402	(char*) nullptr)) {
	403	owner_gid = std::stoi(val);
	404	} else if (ceph_argparse_flag(args, arg_iter, "--verify",
	405	(char*) nullptr)) {
	406	do_verify = true;
	407	} else if (ceph_argparse_flag(args, arg_iter, "--create",
	408	(char*) nullptr)) {
	409	do_create = true;
	410	} else if (ceph_argparse_flag(args, arg_iter, "--delete",
	411	(char*) nullptr)) {
	412	do_delete = true;
224ce89b WB	413	} else if (ceph_argparse_flag(args, arg_iter, "--large",
	414	(char*) nullptr)) {
	415	do_large = true;
7c673cae FG	416	} else if (ceph_argparse_flag(args, arg_iter, "--hexdump",
	417	(char*) nullptr)) {
	418	do_hexdump = true;
	419	} else {
	420	++arg_iter;
	421	}
	422	}
	423
11fdf7f2	424	/* don't accidentally run as anonymous */
7c673cae FG	425	if ((access_key == "") \|\|
	426	(secret_key == "")) {
	427	std::cout << argv[0] << " no AWS credentials, exiting" << std::endl;
	428	return EPERM;
	429	}
	430
	431	saved_args.argc = argc;
	432	saved_args.argv = argv;
	433
	434	::testing::InitGoogleTest(&argc, argv);
	435	return RUN_ALL_TESTS();
	436	}