/*
* Read data from a volume using gfapi.
*/
ssize_t gfapi_device::d_read(int fd, void *buffer, size_t count)
{
if (m_gfd) {
return glfs_read(m_gfd, buffer, count, 0);
} else {
errno = EBADF;
return -1;
}
}
int
main (int argc, char *argv[])
{
glfs_t *fs = NULL;
int ret = 0;
glfs_fd_t *fd = NULL;
struct stat sb = {0, };
char readbuf[32];
char writebuf[32];
char *volname = "iops";
char *filename = "/filename2";
fs = glfs_new (volname);
if (!fs) {
fprintf (stderr, "glfs_new: returned NULL\n");
return 1;
}
// ret = glfs_set_volfile (fs, "/tmp/filename.vol");
ret = glfs_set_volfile_server (fs, "socket", "localhost", 24007);
// ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0);
ret = glfs_set_logging (fs, "/dev/stderr", 7);
ret = glfs_init (fs);
fprintf (stderr, "glfs_init: returned %d\n", ret);
ret = glfs_lstat (fs, filename, &sb);
fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
fd = glfs_creat (fs, filename, O_RDWR, 0644);
fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno));
sprintf (writebuf, "hi there\n");
ret = glfs_write (fd, writebuf, 32, 0);
glfs_lseek (fd, 0, SEEK_SET);
ret = glfs_read (fd, readbuf, 32, 0);
printf ("read %d, %s", ret, readbuf);
glfs_close (fd);
return ret;
}
static int fio_gf_queue(struct thread_data *td, struct io_u *io_u)
{
struct gf_data *g = td->io_ops_data;
int ret = 0;
dprint(FD_FILE, "fio queue len %lu\n", io_u->xfer_buflen);
fio_ro_check(td, io_u);
if (io_u->ddir == DDIR_READ)
ret = glfs_read(g->fd, io_u->xfer_buf, io_u->xfer_buflen, 0);
else if (io_u->ddir == DDIR_WRITE)
ret = glfs_write(g->fd, io_u->xfer_buf, io_u->xfer_buflen, 0);
else if (io_u->ddir == DDIR_SYNC)
ret = glfs_fsync(g->fd);
else if (io_u->ddir == DDIR_DATASYNC)
ret = glfs_fdatasync(g->fd);
else {
log_err("unsupported operation.\n");
return -EINVAL;
}
dprint(FD_FILE, "fio len %lu ret %d\n", io_u->xfer_buflen, ret);
if (io_u->file && ret >= 0 && ddir_rw(io_u->ddir))
LAST_POS(io_u->file) = io_u->offset + ret;
if (ret != (int)io_u->xfer_buflen) {
if (ret >= 0) {
io_u->resid = io_u->xfer_buflen - ret;
io_u->error = 0;
return FIO_Q_COMPLETED;
} else
io_u->error = errno;
}
if (io_u->error) {
log_err("IO failed.\n");
td_verror(td, io_u->error, "xfer");
}
return FIO_Q_COMPLETED;
}
static int uwsgi_glusterfs_request(struct wsgi_request *wsgi_req) {
char filename[PATH_MAX+1];
/* Standard GlusterFS request */
if (!wsgi_req->uh->pktsize) {
uwsgi_log( "Empty GlusterFS request. skip.\n");
return -1;
}
if (uwsgi_parse_vars(wsgi_req)) {
return -1;
}
// blocks empty paths
if (wsgi_req->path_info_len == 0 || wsgi_req->path_info_len > PATH_MAX) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
wsgi_req->app_id = uwsgi_get_app_id(wsgi_req, wsgi_req->appid, wsgi_req->appid_len, glusterfs_plugin.modifier1);
if (wsgi_req->app_id == -1 && !uwsgi.no_default_app && uwsgi.default_app > -1) {
if (uwsgi_apps[uwsgi.default_app].modifier1 == glusterfs_plugin.modifier1) {
wsgi_req->app_id = uwsgi.default_app;
}
}
if (wsgi_req->app_id == -1) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
struct uwsgi_app *ua = &uwsgi_apps[wsgi_req->app_id];
memcpy(filename, wsgi_req->path_info, wsgi_req->path_info_len);
filename[wsgi_req->path_info_len] = 0;
glfs_fd_t *fd = glfs_open((glfs_t *) ua->interpreter, filename, O_RDONLY);
if (!fd) {
uwsgi_404(wsgi_req);
return UWSGI_OK;
}
struct stat st;
if (glfs_fstat(fd, &st)) {
uwsgi_403(wsgi_req);
return UWSGI_OK;
}
if (uwsgi_response_prepare_headers(wsgi_req, "200 OK", 6)) goto end;
size_t mime_type_len = 0;
char *mime_type = uwsgi_get_mime_type(wsgi_req->path_info, wsgi_req->path_info_len, &mime_type_len);
if (mime_type) {
if (uwsgi_response_add_content_type(wsgi_req, mime_type, mime_type_len)) goto end;
}
if (uwsgi_response_add_last_modified(wsgi_req, (uint64_t) st.st_mtime)) goto end;
if (uwsgi_response_add_content_length(wsgi_req, st.st_size)) goto end;
// skip body on HEAD
if (uwsgi_strncmp(wsgi_req->method, wsgi_req->method_len, "HEAD", 4)) {
size_t remains = st.st_size;
while(remains > 0) {
char buf[8192];
ssize_t rlen = glfs_read (fd, buf, UMIN(remains, 8192), 0);
if (rlen <= 0) goto end;
if (uwsgi_response_write_body_do(wsgi_req, buf, rlen)) goto end;
remains -= rlen;
}
}
end:
glfs_close(fd);
return UWSGI_OK;
}
int
main (int argc, char *argv[])
{
glfs_t *fs = NULL;
glfs_t *fs2 = NULL;
int ret = 0;
glfs_fd_t *fd = NULL;
glfs_fd_t *fd2 = NULL;
struct stat sb = {0, };
char readbuf[32];
char writebuf[32];
char *filename = "/filename2";
fs = glfs_new ("fsync");
if (!fs) {
fprintf (stderr, "glfs_new: returned NULL\n");
return 1;
}
// ret = glfs_set_volfile (fs, "/tmp/posix.vol");
ret = glfs_set_volfile_server (fs, "tcp", "localhost", 24007);
// ret = glfs_set_volfile_server (fs, "unix", "/tmp/gluster.sock", 0);
ret = glfs_set_logging (fs, "/dev/stderr", 7);
ret = glfs_init (fs);
fprintf (stderr, "glfs_init: returned %d\n", ret);
sleep (2);
fs2 = glfs_new ("fsync");
if (!fs2) {
fprintf (stderr, "glfs_new: returned NULL\n");
return 1;
}
// ret = glfs_set_volfile (fs2, "/tmp/posix.vol");
ret = glfs_set_volfile_server (fs2, "tcp", "localhost", 24007);
ret = glfs_set_logging (fs2, "/dev/stderr", 7);
ret = glfs_init (fs2);
fprintf (stderr, "glfs_init: returned %d\n", ret);
ret = glfs_lstat (fs, filename, &sb);
fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
fd = glfs_creat (fs, filename, O_RDWR, 0644);
fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno));
fd2 = glfs_open (fs2, filename, O_RDWR);
fprintf (stderr, "%s: (%p) %s\n", filename, fd, strerror (errno));
sprintf (writebuf, "hi there\n");
ret = glfs_write (fd, writebuf, 32, 0);
glfs_lseek (fd2, 0, SEEK_SET);
ret = glfs_read (fd2, readbuf, 32, 0);
printf ("read %d, %s", ret, readbuf);
glfs_close (fd);
glfs_close (fd2);
filename = "/filename3";
ret = glfs_mknod (fs, filename, S_IFIFO, 0);
fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
ret = glfs_lstat (fs, filename, &sb);
fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
ret = glfs_rename (fs, filename, "/filename4");
fprintf (stderr, "rename(%s): (%d) %s\n", filename, ret,
strerror (errno));
ret = glfs_unlink (fs, "/filename4");
fprintf (stderr, "unlink(%s): (%d) %s\n", "/filename4", ret,
strerror (errno));
filename = "/dirname2";
ret = glfs_mkdir (fs, filename, 0);
fprintf (stderr, "%s: (%d) %s\n", filename, ret, strerror (errno));
ret = glfs_lstat (fs, filename, &sb);
fprintf (stderr, "lstat(%s): (%d) %s\n", filename, ret, strerror (errno));
ret = glfs_rmdir (fs, filename);
fprintf (stderr, "rmdir(%s): (%d) %s\n", filename, ret, strerror (errno));
test_dirops (fs);
test_xattr (fs);
test_chdir (fs);
// done
glfs_fini (fs);
glfs_fini (fs2);
return ret;
}
long
glfs_java_read (glfs_fd_t *glfd, b_array *io_data, size_t size)
{
return glfs_read (glfd, io_data, size, 0);
}
static int
large_read_write (glfs_t *fs) {
int ret = 0;
int j = 0;
glfs_fd_t *fd = NULL;
glfs_fd_t *fd1 = NULL;
char *filename = NULL;
char *buf = NULL;
ret = asprintf (&filename, "filerw%d", extension);
if (ret < 0) {
fprintf (stderr, "cannot construct filename (%s)",
strerror (errno));
return ret;
}
extension++;
fd = glfs_creat (fs, filename, O_RDWR, 0644);
if (!fd) {
fprintf (stderr, "%s: (%p) %s\n", filename, fd,
strerror (errno));
return -1;
}
buf = (char *) malloc (WRITE_SIZE);
memset (buf, '-', WRITE_SIZE);
for (j = 0; j < READ_WRITE_LOOP; j++) {
ret = glfs_write (fd, buf, WRITE_SIZE, 0);
if (ret < 0) {
fprintf (stderr, "Write(%s): %d (%s)\n", filename, ret,
strerror (errno));
return ret;
}
}
fd1 = glfs_open (fs, filename, O_RDWR);
if (fd1 < 0) {
fprintf (stderr, "Open(%s): %d (%s)\n", filename, ret,
strerror (errno));
return -1;
}
glfs_lseek (fd1, 0, SEEK_SET);
for (j = 0; j < READ_WRITE_LOOP; j++) {
ret = glfs_read (fd1, buf, WRITE_SIZE, 0);
if (ret < 0) {
fprintf (stderr, "Read(%s): %d (%s)\n", filename, ret,
strerror (errno));
return ret;
}
}
for (j = 0; j < READ_WRITE_LOOP; j++) {
ret = glfs_write (fd1, buf, WRITE_SIZE, 0);
if (ret < 0) {
fprintf (stderr, "Write(%s): %d (%s)\n", filename, ret,
strerror (errno));
return ret;
}
}
glfs_close (fd);
glfs_close (fd1);
ret = glfs_unlink (fs, filename);
if (ret < 0) {
fprintf (stderr, "glfs_unlink failed with ret: %d (%s)\n",
ret, strerror (errno));
return -1;
}
free (buf);
free (filename);
}
