/*
* the following function is for client,
* server/daemon process shouldn't call it.
* Because this function may read incorrect setting from user specified
* $USER or $HOME.
*/
gfarm_error_t
gfarm_terminate(void)
{
#if 0 /* not yet in gfarm v2 */
gfarm_error_t e;
gfs_profile(gfs_display_timers());
if (gf_stdout != NULL) {
fflush(stdout);
e = gfs_pio_close(gf_stdout);
gf_stdout = NULL;
if (e != GFARM_ERR_NO_ERROR)
return (e);
}
if (gf_stderr != NULL) {
fflush(stderr);
e = gfs_pio_close(gf_stderr);
gf_stderr = NULL;
if (e != GFARM_ERR_NO_ERROR)
return (e);
}
e = gfarm_metadb_terminate();
if (e != GFARM_ERR_NO_ERROR)
return (e);
#endif /* not yet in gfarm v2 */
return (GFARM_ERR_NO_ERROR);
}
int
gfs_hook_insert_gfs_file(GFS_File gf)
{
int fd, save_errno;
_gfs_hook_debug(fprintf(stderr, "gfs_hook_insert_gfs_file: %p\n", gf));
fd = dup(gfs_pio_fileno(gf));
if (fd == -1) {
save_errno = errno;
gfs_pio_close(gf);
errno = save_errno;
return (-1);
}
if (fd >= MAX_GFS_FILE_BUF) {
__syscall_close(fd);
gfs_pio_close(gf);
errno = EMFILE;
return (-1);
}
if (_gfs_file_buf[fd] != NULL) {
__syscall_close(fd);
gfs_pio_close(gf);
errno = EBADF; /* XXX - something broken */
return (-1);
}
_gfs_file_buf[fd] = gf;
return (fd);
}
/*
* Instead of just calling gfs_pio_set_view_index(),
* we use another GFS_File to move to another fragment.
* This is because we don't want to leave this context inconsistent,
* if failure happens at the gfs_pio_set_view_index().
*/
static char *
gfs_pio_view_global_move_to(GFS_File gf, int fragment_index)
{
struct gfs_file_global_context *gc = gf->view_context;
char *e;
GFS_File new_fragment;
if ((gf->open_flags & GFARM_FILE_CREATE) != 0)
e = gfs_pio_create(gc->url, gf->open_flags,
gf->pi.status.st_mode & GFARM_S_ALLPERM,
&new_fragment);
else
e = gfs_pio_open(gc->url, gf->open_flags, &new_fragment);
if (e != NULL)
return (e);
e = gfs_pio_set_view_index(new_fragment, gf->pi.status.st_nsections,
fragment_index, NULL, gf->view_flags);
if (e != NULL) {
gfs_pio_close(new_fragment);
return (e);
}
if (gc->fragment_gf != NULL) {
gfs_pio_close(gc->fragment_gf);
/* XXX need a way to report error on here */
}
gc->fragment_gf = new_fragment;
gc->fragment_index = fragment_index;
return (NULL);
}
int
gfs_hook_insert_gfs_file(GFS_File gf)
{
int fd, save_errno;
struct stat st;
_gfs_hook_debug(fprintf(stderr, "GFS: insert_gfs_file: %p\n", gf));
/*
* A new file descriptor is needed to identify a hooked file
* descriptor.
*/
fd = gfs_pio_fileno(gf);
if (fstat(fd, &st) == -1) {
save_errno = errno;
gfs_hook_delete_creating_file(gf);
gfs_pio_close(gf);
errno = save_errno;
return (-1);
}
if (S_ISREG(st.st_mode))
fd = dup(fd);
else /* don't return a socket, to make select(2) work with this fd */
fd = open("/dev/null", O_RDWR);
if (fd == -1) {
save_errno = errno;
gfs_hook_delete_creating_file(gf);
gfs_pio_close(gf);
errno = save_errno;
return (-1);
}
if (fd >= MAX_GFS_FILE_BUF) {
__syscall_close(fd);
gfs_hook_delete_creating_file(gf);
gfs_pio_close(gf);
errno = EMFILE;
return (-1);
}
if (_gfs_file_buf[fd] != NULL) {
__syscall_close(fd);
gfs_hook_delete_creating_file(gf);
gfs_pio_close(gf);
errno = EBADF; /* XXX - something broken */
return (-1);
}
_gfs_file_buf[fd] = malloc(sizeof(*_gfs_file_buf[fd]));
if (_gfs_file_buf[fd] == NULL) {
__syscall_close(fd);
gfs_hook_delete_creating_file(gf);
gfs_pio_close(gf);
errno = ENOMEM;
return (-1);
}
_gfs_file_buf[fd]->refcount = 1;
_gfs_file_buf[fd]->d_type = GFS_DT_REG;
_gfs_file_buf[fd]->u.f = gf;
return (fd);
}
static void
register_fragment(int is_dir, char *gfarm_url, int index, int nfragments,
char *hostname,
char *filename, int use_file_mode, gfarm_mode_t file_mode)
{
char *e;
int fd, fd_needs_close;
char *target_url;
GFS_File gf;
char section[GFARM_INT32STRLEN + 1];
if (!open_file(filename, &fd, &fd_needs_close))
return;
if (!use_file_mode && !get_file_mode(fd, filename, &file_mode))
goto finish;
if (!is_dir)
target_url = gfarm_url;
else if (!concat_dir_name(gfarm_url, gfarm_path_dir_skip(filename),
&target_url))
goto finish;
if (nfragments == GFARM_FILE_DONTCARE &&
!get_nsections(target_url, &nfragments))
goto finish_url;
sprintf(section, "%d", index);
if (opt_force || section_does_not_exists(target_url, section)) {
e = gfs_pio_create(target_url,
GFARM_FILE_WRONLY|GFARM_FILE_TRUNC, file_mode, &gf);
if (e != NULL) {
fprintf(stderr, "%s: cannot open %s: %s\n",
program_name, target_url, e);
error_happened = 1;
} else {
if ((e = gfs_pio_set_view_index(gf, nfragments, index,
hostname, 0)) != NULL) {
fprintf(stderr, "%s: cannot open %s:%d: %s\n",
program_name, target_url, index, e);
error_happened = 1;
} else {
copy_file(fd, gf, target_url, section);
}
gfs_pio_close(gf);
}
}
finish_url:
if (target_url != gfarm_url)
free(target_url);
finish:
if (fd_needs_close)
close(fd);
}
static char *
gfs_pio_view_global_close(GFS_File gf)
{
struct gfs_file_global_context *gc = gf->view_context;
char *e;
e = gfs_pio_close(gc->fragment_gf);
free(gc->url);
free(gc->offsets);
free(gc);
gf->view_context = NULL;
gfs_pio_set_view_default(gf);
return (e);
}
static void
register_program(int is_dir, char *gfarm_url, char *section, char *hostname,
char *filename, int use_file_mode, gfarm_mode_t file_mode)
{
char *e;
int fd, fd_needs_close;
char *target_url;
GFS_File gf;
if (!open_file(filename, &fd, &fd_needs_close))
return;
if (!use_file_mode && !get_file_mode(fd, filename, &file_mode))
goto finish;
if (!is_dir)
target_url = gfarm_url;
else if (!concat_dir_name(gfarm_url, gfarm_path_dir_skip(filename),
&target_url))
goto finish;
if (opt_force || section_does_not_exists(target_url, section)) {
e = gfs_pio_create(target_url,
GFARM_FILE_WRONLY|GFARM_FILE_TRUNC, file_mode, &gf);
if (e != NULL) {
fprintf(stderr, "%s: cannot open %s: %s\n",
program_name, target_url, e);
error_happened = 1;
} else {
if ((e = gfs_pio_set_view_section(gf, section,
hostname, 0)) != NULL) {
fprintf(stderr, "%s: cannot open %s:%s: %s\n",
program_name, target_url, section, e);
error_happened = 1;
} else {
copy_file(fd, gf, target_url, section);
}
gfs_pio_close(gf);
}
}
if (target_url != gfarm_url)
free(target_url);
finish:
if (fd_needs_close)
close(fd);
}
static gfarm_error_t
gfs_replicate_to_internal(char *file, char *dsthost, int dstport, int migrate)
{
char *srchost;
int srcport;
gfarm_error_t e, e2;
GFS_File gf;
e = gfs_pio_open(file, GFARM_FILE_RDONLY, &gf);
if (e != GFARM_ERR_NO_ERROR) {
gflog_debug(GFARM_MSG_1001389,
"gfs_pio_open(%s) failed: %s",
file,
gfarm_error_string(e));
return (e);
}
e = gfarm_schedule_file(gf, &srchost, &srcport);
if (e == GFARM_ERR_NO_ERROR) {
#ifndef V2_4
e = gfs_replicate_from_to_internal(gf, srchost, srcport,
dsthost, dstport);
#else
e = gfs_replicate_file_from_to(file, srchost, dsthost,
GFS_REPLICATE_FILE_FORCE
/* | GFS_REPLICATE_FILE_WAIT */ /* XXX NOTYET */);
#endif
if (e == GFARM_ERR_NO_ERROR && migrate)
e = gfs_replica_remove_by_file(file, srchost);
free(srchost);
}
e2 = gfs_pio_close(gf);
if (e != GFARM_ERR_NO_ERROR || e2 != GFARM_ERR_NO_ERROR) {
gflog_debug(GFARM_MSG_1001390,
"error occurred in gfs_replicate_to_internal(): %s",
gfarm_error_string(e != GFARM_ERR_NO_ERROR ? e : e2));
}
return (e != GFARM_ERR_NO_ERROR ? e : e2);
}
static char *
gfs_pio_view_global_close(GFS_File gf)
{
struct gfs_file_global_context *gc = gf->view_context;
char *e, *e_save = NULL;
if ((gf->mode & GFS_FILE_MODE_WRITE) != 0) {
e = gfs_pio_flush(gf);
if (e != NULL)
e_save = e;
}
e = gfs_pio_close(gc->fragment_gf);
free(gc->url);
free(gc->offsets);
free(gc);
gf->view_context = NULL;
gfs_pio_set_view_default(gf);
return (e_save != NULL ? e_save : e);
}
gfarm_error_t
gfs_replicate_from_to(char *file, char *srchost, int srcport,
char *dsthost, int dstport)
{
#ifndef V2_4
gfarm_error_t e, e2;
GFS_File gf;
if (srchost == NULL)
return (gfs_replicate_to(file, dsthost, dstport));
e = gfs_pio_open(file, GFARM_FILE_RDONLY, &gf);
if (e != GFARM_ERR_NO_ERROR) {
gflog_debug(GFARM_MSG_1001392,
"gfs_pio_open(%s) failed: %s",
file,
gfarm_error_string(e));
return (e);
}
e = gfs_replicate_from_to_internal(gf, srchost, srcport,
dsthost, dstport);
e2 = gfs_pio_close(gf);
if (e != GFARM_ERR_NO_ERROR || e2 != GFARM_ERR_NO_ERROR) {
gflog_debug(GFARM_MSG_1001393,
"replication failed (%s) from (%s:%d) to (%s:%d): %s",
file, srchost, srcport, dsthost, dstport,
gfarm_error_string(e != GFARM_ERR_NO_ERROR ? e : e2));
}
return (e != GFARM_ERR_NO_ERROR ? e : e2);
#else
return (gfs_replicate_file_from_to(file, srchost, dsthost,
GFS_REPLICATE_FILE_FORCE
/* | GFS_REPLICATE_FILE_WAIT */ /* XXX NOTYET */));
#endif
}
gfarm_error_t
gfs_replicate_file_to_request(
const char *file, const char *dsthost, int flags)
{
char *srchost;
int srcport;
gfarm_error_t e, e2;
GFS_File gf;
e = gfs_pio_open(file, GFARM_FILE_RDONLY, &gf);
if (e != GFARM_ERR_NO_ERROR)
return (e);
e = gfarm_schedule_file(gf, &srchost, &srcport);
e2 = gfs_pio_close(gf);
if (e == GFARM_ERR_NO_ERROR) {
e = gfs_replicate_file_from_to_request(file, srchost,
dsthost, flags);
free(srchost);
}
return (e != GFARM_ERR_NO_ERROR ? e : e2);
}
char *
gfs_hook_clear_gfs_file(int fd)
{
GFS_File gf;
char *e = NULL;
_gfs_hook_debug(fprintf(stderr, "GFS: clear_gfs_file: %d\n", fd));
gf = gfs_hook_is_open(fd);
if (gf == NULL) {
_gfs_hook_debug(fprintf(stderr,
"GFS: ERROR: not a Gfarm file: %d\n", fd));
return ("not a Gfarm file");
}
if (--_gfs_file_buf[fd]->refcount > 0) {
/* fd is duplicated, skip closing the file. */
_gfs_hook_debug(fprintf(stderr,
"GFS: clear_gfs_file: skipped\n"));
} else {
if (gfs_hook_gfs_file_type(fd) == GFS_DT_REG) {
gfs_hook_delete_creating_file(gf);
e = gfs_pio_close(gf);
} else if (gfs_hook_gfs_file_type(fd) == GFS_DT_DIR) {
_gfs_file_buf[fd]->u.d->dir = NULL;
_gfs_file_buf[fd]->u.d->suspended = NULL;
gfs_stat_free(&_gfs_file_buf[fd]->u.d->gst);
free(_gfs_file_buf[fd]->u.d->canonical_path);
free(_gfs_file_buf[fd]->u.d);
e = gfs_closedir((GFS_Dir)gf);
}
free(_gfs_file_buf[fd]);
}
__syscall_close(fd);
_gfs_file_buf[fd] = NULL;
return (e);
}
int webgfarm_api_v1_write_to_file(request_rec *r) {
// get filepath from request
char *filepath = webgfarm_api_v1_getfilepath(r);
if (filepath == NULL || strlen(filepath) == 0) {
return HTTP_FORBIDDEN;
}
gfarm_error_t gerr;
GFS_File gfs_file;
webgfarm_config *wconfig = ap_get_module_config(r->server->module_config, &webgfarm_module);
if (wconfig->write_redirect) {
char *redirect_url = apr_palloc(r->pool, sizeof (char)*WEBGFARM_BUFFER_SIZE);
const char *port;
int available_nhosts;
struct gfarm_host_sched_info *available_hosts;
gerr = gfarm_schedule_hosts_domain_by_file(filepath, GFARM_FILE_RDONLY, "", &available_nhosts, &available_hosts);
if (available_nhosts > 0) {
if (gerr == GFARM_ERR_NO_ERROR) {
int *ports;
char **hosts;
int nhosts = available_nhosts;
int i;
GFARM_MALLOC_ARRAY(hosts, available_nhosts);
GFARM_MALLOC_ARRAY(ports, available_nhosts);
gerr = gfarm_schedule_hosts_acyclic_to_write(filepath, available_nhosts, available_hosts, &nhosts, hosts, ports);
if (nhosts > 0 && gerr == GFARM_ERR_NO_ERROR) {
for (i = 0; i < nhosts; i++) {
port = apr_table_get(wconfig->hosts, hosts[i]);
if (port != NULL) {
if (strcmp(wconfig->localhost, hosts[i]) != 0) {
if (wconfig->ssl) {
snprintf(redirect_url, WEBGFARM_BUFFER_SIZE, "https://%s:%s%s", hosts[i], port, r->uri);
} else {
snprintf(redirect_url, WEBGFARM_BUFFER_SIZE, "http://%s:%s%s", hosts[i], port, r->uri);
}
apr_table_set(r->headers_out, "Location", redirect_url);
free(ports);
free(hosts);
return HTTP_TEMPORARY_REDIRECT;
} else {
break;
}
}
}
}
free(ports);
free(hosts);
} else if (gerr != GFARM_ERR_NO_SUCH_FILE_OR_DIRECTORY) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "gfarm_schedule_hosts_domain_by_file can not get the hosts of the file(%s) with error: %s", filepath, gfarm_error_string(gerr));
return HTTP_INTERNAL_SERVER_ERROR;
}
}
}
// open
if (r->method_number == M_POST) {
gerr = gfs_pio_open(filepath, GFARM_FILE_WRONLY | GFARM_FILE_APPEND, &gfs_file);
} else if (r->method_number == M_PUT) {
gerr = gfs_pio_open(filepath, GFARM_FILE_WRONLY | GFARM_FILE_TRUNC, &gfs_file);
if (gerr == GFARM_ERR_NO_SUCH_FILE_OR_DIRECTORY) {
gerr = gfs_pio_create(filepath, GFARM_FILE_WRONLY, 0644, &gfs_file);
}
} else {
return HTTP_INTERNAL_SERVER_ERROR;
}
if (gerr != GFARM_ERR_NO_ERROR) {
switch (gerr) {
case GFARM_ERR_NO_SUCH_FILE_OR_DIRECTORY:
return HTTP_NOT_FOUND;
break;
case GFARM_ERR_PERMISSION_DENIED:
return HTTP_FORBIDDEN;
break;
//FIXEME: Support more error;
default:
return HTTP_INTERNAL_SERVER_ERROR;
}
}
// get input body size;
int in_size;
const char *clen = apr_table_get(r->headers_in, "Content-Length");
if (clen != NULL) {
in_size = strtol(clen, NULL, 0);
if (in_size >= WEBGFFARM_MAX_POST_SIZE) {
gfs_pio_close(gfs_file);
return HTTP_BAD_REQUEST;
}
} else {
gfs_pio_close(gfs_file);
return HTTP_BAD_REQUEST;
}
if (in_size != 0) {
apr_off_t size = 0;
char *buf;
if (util_read(r, &buf, &size) != OK) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "[write] failed reading POST body");
gfs_pio_close(gfs_file);
return HTTP_INTERNAL_SERVER_ERROR;
}
in_size = (int) size;
if (buf == NULL) {
return HTTP_BAD_REQUEST;
}
// write buffer
int write_size;
gerr = gfs_pio_write(gfs_file, buf, in_size, &write_size);
if (gerr != GFARM_ERR_NO_ERROR) {
if (in_size != write_size) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "[write] gfs_pio_write failure..(in: %d, out: %d)", (int) in_size, (int) write_size);
}
gerr = gfs_pio_close(gfs_file);
return HTTP_INTERNAL_SERVER_ERROR;
}
}
// close
gerr = gfs_pio_close(gfs_file);
if (gerr != GFARM_ERR_NO_ERROR) {
return HTTP_INTERNAL_SERVER_ERROR;
} else {
return OK;
}
}
gfarm_error_t
gfperf_create_file_on_gfarm(const char *url, char *hostname,
long long file_size)
{
const char *filename;
char *buf;
long long leftsize;
int ret, s;
GFS_File fp;
gfarm_error_t e;
struct gfs_stat sb;
filename = url;
GFARM_CALLOC_ARRAY(buf, GFPERF_COPY_BUF_SIZE);
if (buf == NULL) {
fprintf(stderr, "can not allocate memory.\n");
return (GFARM_ERR_NO_MEMORY);
}
e = gfs_stat(filename, &sb);
if (e != GFARM_ERR_NO_SUCH_FILE_OR_DIRECTORY) {
fprintf(stderr, "file exists: %s\n", filename);
if (e == GFARM_ERR_NO_ERROR)
gfs_stat_free(&sb);
free(buf);
return (GFARM_ERR_ALREADY_EXISTS);
}
e = gfs_pio_create(filename,
GFARM_FILE_WRONLY|GFARM_FILE_TRUNC,
0644,
&fp);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "open: %s\n",
gfarm_error_string(e));
free(buf);
return (e);
}
if (hostname != NULL) {
/* XXX FIXME: INTERNAL FUNCTION SHOULD NOT BE USED */
e = gfs_pio_internal_set_view_section(fp, hostname);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr,
"gfs_pio_internal_set_view_section() error! "
"%s: %s\n", hostname,
gfarm_error_string(e));
goto err_return;
}
}
for (leftsize = file_size; leftsize > 0 ; leftsize -= ret) {
s = (leftsize < GFPERF_COPY_BUF_SIZE) ?
leftsize : GFPERF_COPY_BUF_SIZE;
e = gfs_pio_write(fp, buf, s, &ret);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "write: %s\n",
gfarm_error_string(e));
goto err_return;
}
}
e = gfs_pio_close(fp);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "close: %s\n",
gfarm_error_string(e));
}
free(buf);
return (e);
err_return:
gfs_pio_close(fp);
free(buf);
return (e);
}
int webgfarm_api_v1_read_file(request_rec *r) {
// get filepath from request
char *filepath = webgfarm_api_v1_getfilepath(r);
if (filepath == NULL || strlen(filepath) == 0) {
return HTTP_FORBIDDEN;
}
webgfarm_config *wconfig = ap_get_module_config(r->server->module_config, &webgfarm_module);
gfarm_error_t gerr;
GFS_File gfs_file;
if (wconfig->read_redirect) {
// ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "[read] read_redirect is on.");
char *redirect_url = apr_palloc(r->pool, sizeof (char)*WEBGFARM_BUFFER_SIZE);
const char *port;
int available_nhosts;
struct gfarm_host_sched_info *available_hosts;
gerr = gfarm_schedule_hosts_domain_by_file(filepath, GFARM_FILE_RDONLY, "", &available_nhosts, &available_hosts);
if (gerr == GFARM_ERR_NO_ERROR) {
// ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "[read] gfarm_schedule_hosts_domain_by_file() has no error.");
int *ports;
char **hosts;
int nhosts = available_nhosts;
int i;
GFARM_MALLOC_ARRAY(hosts, available_nhosts);
GFARM_MALLOC_ARRAY(ports, available_nhosts);
gerr = gfarm_schedule_hosts_acyclic(filepath, available_nhosts, available_hosts, &nhosts, hosts, ports);
if (nhosts > 0 && gerr == GFARM_ERR_NO_ERROR) {
// ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "[read] gfarm_schedule_hosts_acyclic() has no error.");
for (i = 0; i < nhosts; i++) {
port = apr_table_get(wconfig->hosts, hosts[i]);
if (port != NULL) {
if (strcmp(wconfig->localhost, hosts[i]) != 0) {
if (wconfig->ssl) {
snprintf(redirect_url, WEBGFARM_BUFFER_SIZE, "https://%s:%s%s", hosts[i], port, r->uri);
} else {
snprintf(redirect_url, WEBGFARM_BUFFER_SIZE, "http://%s:%s%s", hosts[i], port, r->uri);
}
apr_table_set(r->headers_out, "Location", redirect_url);
free(ports);
free(hosts);
return HTTP_TEMPORARY_REDIRECT;
} else {
break;
}
}
}
}
free(ports);
free(hosts);
} else if (gerr != GFARM_ERR_NO_SUCH_FILE_OR_DIRECTORY) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "gfarm_schedule_hosts_domain_by_file can not get the hosts of the file(%s) with error: %s", filepath, gfarm_error_string(gerr));
return HTTP_INTERNAL_SERVER_ERROR;
}
}
// open
gerr = gfs_pio_open(filepath, GFARM_FILE_RDONLY, &gfs_file);
if (gerr != GFARM_ERR_NO_ERROR) {
switch (gerr) {
case GFARM_ERR_NO_SUCH_FILE_OR_DIRECTORY:
return HTTP_NOT_FOUND;
break;
case GFARM_ERR_PERMISSION_DENIED:
return HTTP_FORBIDDEN;
break;
//FIXEME: Support more error;
default:
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "gfs_pio_open can not open the file(%s) with error: %s", filepath, gfarm_error_string(gerr));
return HTTP_INTERNAL_SERVER_ERROR;
}
}
// get stat
struct gfs_stat gs;
gerr = gfs_pio_stat(gfs_file, &gs);
if (gerr != GFARM_ERR_NO_ERROR) {
gfs_pio_close(gfs_file);
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "gfs_pio_stat can not get the stat of the file(%s) with error: %s", filepath, gfarm_error_string(gerr));
return HTTP_INTERNAL_SERVER_ERROR;
}
char *stat_buffer = apr_palloc(r->pool, sizeof (char)*WEBGFARM_BUFFER_SIZE);
snprintf(stat_buffer, WEBGFARM_BUFFER_SIZE, "%lu", gs.st_ino);
apr_table_set(r->headers_out, "X-WEBGFARM-STAT-INO", stat_buffer);
snprintf(stat_buffer, WEBGFARM_BUFFER_SIZE, "%lu", gs.st_gen);
apr_table_set(r->headers_out, "X-WEBGFARM-STAT-GEN", stat_buffer);
snprintf(stat_buffer, WEBGFARM_BUFFER_SIZE, "%o", gs.st_mode);
apr_table_set(r->headers_out, "X-WEBGFARM-STAT-MODE", stat_buffer);
snprintf(stat_buffer, WEBGFARM_BUFFER_SIZE, "%lu", gs.st_nlink);
apr_table_set(r->headers_out, "X-WEBGFARM-STAT-NLINK", stat_buffer);
apr_table_set(r->headers_out, "X-WEBGFARM-STAT-USER", gs.st_user);
apr_table_set(r->headers_out, "X-WEBGFARM-STAT-GROUP", gs.st_group);
snprintf(stat_buffer, WEBGFARM_BUFFER_SIZE, "%lu", gs.st_size);
apr_table_set(r->headers_out, "X-WEBGFARM-STAT-SIZE", stat_buffer);
snprintf(stat_buffer, WEBGFARM_BUFFER_SIZE, "%lu", gs.st_ncopy);
apr_table_set(r->headers_out, "X-WEBGFARM-STAT-NCOPY", stat_buffer);
// gerr == GFARM_ERR_NO_ERROR
//read and puts
if (!r->header_only) {
char *buf = apr_palloc(r->pool, sizeof (char)*WEBGFARM_BUFFER_SIZE);
int read_size = 0;
do {
gerr = gfs_pio_read(gfs_file, buf, WEBGFARM_BUFFER_SIZE, &read_size);
if (gerr != GFARM_ERR_NO_ERROR) {
gerr = gfs_pio_close(gfs_file);
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "gfs_pio_read can not read the file(%s) with error: %s", filepath, gfarm_error_string(gerr));
return HTTP_INTERNAL_SERVER_ERROR;
} else {
if (read_size != 0) {
ap_rwrite(buf, read_size, r);
}
}
} while (gerr == GFARM_ERR_NO_ERROR && read_size != 0);
}
// close
gerr = gfs_pio_close(gfs_file);
if (gerr != GFARM_ERR_NO_ERROR) {
ap_log_rerror(APLOG_MARK, APLOG_ERR, 0, r, "gfs_pio_close can not close the file(%s) with error: %s", filepath, gfarm_error_string(gerr));
return HTTP_INTERNAL_SERVER_ERROR;
} else {
return OK;
}
}
static char *
gfsck_file(char *gfarm_url)
{
char *gfarm_file, *e, *e_save = NULL;
int i, nsections, valid_nsections = 0;
struct gfarm_file_section_info *sections;
GFS_File gf;
e = gfarm_url_make_path(gfarm_url, &gfarm_file);
if (e != NULL)
return (e);
e = gfarm_file_section_info_get_all_by_file(
gfarm_file, &nsections, §ions);
if (e != NULL) {
/* no section info, remove path info */
e = path_info_remove(gfarm_url, gfarm_file);
free(gfarm_file);
return (e);
}
e = gfs_pio_open(gfarm_url, GFARM_FILE_RDONLY, &gf);
if (e != NULL) {
free(gfarm_file);
return (e);
}
for (i = 0; i < nsections; i++) {
int j, ncopies, valid_ncopies = 0;
struct gfarm_file_section_copy_info *copies;
char *section = sections[i].section;
e = gfarm_file_section_copy_info_get_all_by_section(
gfarm_file, section, &ncopies, &copies);
if (e == GFARM_ERR_NO_SUCH_OBJECT) {
/* no section copy info, remove section info */
e = section_info_remove(gfarm_url, gfarm_file, section);
if (e != NULL && e_save == NULL)
e_save = e;
continue;
}
else if (e != NULL) {
fprintf(stderr, "%s (%s): %s\n",
gfarm_url, section, e);
if (e_save == NULL)
e_save = e;
continue;
}
for (j = 0; j < ncopies; ++j) {
if (option_verbose)
printf("%s (%s) on %s\n", gfarm_url, section,
copies[j].hostname);
e = gfs_pio_set_view_section(gf, section,
copies[j].hostname,
GFARM_FILE_NOT_REPLICATE | GFARM_FILE_NOT_RETRY);
if (e == GFARM_ERR_INCONSISTENT_RECOVERABLE) {
/* invalid section copy info removed */
printf("%s (%s) on %s: "
"invalid metadata deleted\n",
gfarm_url, section,
copies[j].hostname);
e = NULL;
}
else {
++valid_ncopies;
if (e != NULL) {
fprintf(stderr, "%s (%s) on %s: %s\n",
gfarm_url, section,
copies[j].hostname, e);
if (e_save == NULL)
e_save = e;
}
}
}
gfarm_file_section_copy_info_free_all(ncopies, copies);
if (valid_ncopies == 0) {
/* no section copy info, remove section info */
e = section_info_remove(gfarm_url, gfarm_file, section);
if (e != NULL && e_save == NULL)
e_save = e;
}
else
++valid_nsections;
}
if (valid_nsections == 0) {
/* no section info, remove path info */
e = path_info_remove(gfarm_url, gfarm_file);
if (e != NULL && e_save == NULL)
e_save = e;
}
else if (valid_nsections < nsections) {
printf("%s: warning: number of file sections reduced\n",
gfarm_url);
}
gfarm_file_section_info_free_all(nsections, sections);
free(gfarm_file);
e = gfs_pio_close(gf);
if (e != NULL)
return (e);
return (e_save);
}
static char *
gfarm_url_fragment_register(char *gfarm_url, char *section, int nfrags,
char *hostname, char *filename)
{
char *e, *e_save = NULL;
int fd;
size_t rv;
int length; /* XXX - should be size_t */
GFS_File gf;
struct stat s;
char buffer[GFS_FILE_BUFSIZE];
/*
* register the fragment
*/
if (strcmp(filename, "-") == 0) {
fd = 0; /* stdin */
s.st_mode = 0664; /* XXX */
}
else {
if (stat(filename, &s) == -1)
return "no such file or directory";
fd = open(filename, O_RDONLY);
if (fd == -1)
return "cannot open";
}
e = gfs_pio_create(gfarm_url, GFARM_FILE_WRONLY,
s.st_mode & GFARM_S_ALLPERM, &gf);
if (e != NULL) {
close(fd);
return (e);
}
if (nfrags == GFARM_FILE_DONTCARE)
e = gfs_pio_set_view_section(gf, section, hostname, 0);
else
e = gfs_pio_set_view_index(gf, nfrags,
strtol(section, NULL, 0), hostname, 0);
if (e != NULL) {
char *gfarm_file;
gfs_pio_close(gf);
close(fd);
/* try to unlink path info when there is no fragment file */
if (gfarm_url_make_path(gfarm_url, &gfarm_file) == NULL) {
(void)gfarm_path_info_remove(gfarm_file);
free(gfarm_file);
}
return (e);
}
for (;;) {
rv = read(fd, buffer, sizeof(buffer));
if (rv <= 0)
break;
/* XXX - partial write case ? */
e = gfs_pio_write(gf, buffer, rv, &length);
if (e != NULL)
break;
}
e_save = e;
e = gfs_pio_close(gf);
close(fd);
if (e_save != NULL)
return (e_save);
return (e);
}
char *
gfarm_url_program_register(char *gfarm_url, char *architecture,
char *filename, int nreplicas)
{
char *e, *e_save = NULL, *if_hostname, *gfarm_file;
int nhosts, fd, i;
struct gfarm_host_info *hosts;
struct sockaddr peer_addr;
size_t rv;
int length; /* XXX - should be size_t */
GFS_File gf;
struct stat s;
char buffer[GFS_FILE_BUFSIZE];
char *self_name;
char **hostnames;
if (stat(filename, &s) == -1)
return (gfarm_errno_to_error(errno));
if (!GFARM_S_IS_PROGRAM(s.st_mode))
return (GFARM_ERR_OPERATION_NOT_PERMITTED);
/* XXX - use better strategy for the replication */
e = gfarm_host_info_get_allhost_by_architecture(architecture,
&nhosts, &hosts);
if (e == GFARM_ERR_NO_SUCH_OBJECT)
return ("gfarm_url_program_register(): no such architecture");
if (e != NULL)
goto finish;
hostnames = malloc(sizeof(char *) * nhosts);
if (hostnames == NULL) {
e = GFARM_ERR_NO_MEMORY;
goto finish_host_info;
}
for (i = 0; i < nhosts; i++)
hostnames[i] = hosts[i].hostname;
if (nhosts < nreplicas)
nreplicas = nhosts;
if (gfarm_host_get_canonical_self_name(&self_name) != NULL) {
e = gfarm_schedule_search_idle_hosts(nhosts, hostnames,
nreplicas, hostnames);
} else {
/* give the top priority to self host */
char * tmp;
for (i = 0; i < nhosts; i++)
if (strcmp(hostnames[i], self_name) == 0)
break;
if (i != 0 && i < nhosts) {
tmp = hostnames[0];
hostnames[0] = hostnames[i];
hostnames[i] = tmp;
}
if (nreplicas > 1)
e = gfarm_schedule_search_idle_hosts(nhosts - 1,
hostnames + 1,
nreplicas - 1,
hostnames + 1);
}
if (e != NULL)
goto finish_hostnames;
/* reflect "address_use" directive in the `hostnames[0]' */
e = gfarm_host_address_get(hostnames[0], gfarm_spool_server_port,
&peer_addr, &if_hostname);
if (e != NULL)
goto finish_hostnames;
/*
* register the program
*/
fd = open(filename, O_RDONLY);
if (fd == -1) {
e = "gfarm_url_program_register(): can't open program";
goto finish_if_hostname;
}
/* XXX - overwrite case */
e = gfs_pio_create(gfarm_url, GFARM_FILE_WRONLY,
s.st_mode & GFARM_S_ALLPERM, &gf);
if (e != NULL) {
close(fd);
goto finish_if_hostname;
}
/* XXX - better strategy to select replica */
e = gfs_pio_set_view_section(gf, architecture, if_hostname, 0);
if (e != NULL) {
/* XXX - take care of the case where node is down */
gfs_pio_close(gf);
close(fd);
goto finish_if_hostname;
}
for (;;) {
rv = read(fd, buffer, sizeof(buffer));
if (rv <= 0)
break;
/* XXX - partial write case ? */
e = gfs_pio_write(gf, buffer, rv, &length);
if (e != NULL)
break;
}
e_save = e;
e = gfs_pio_close(gf);
close(fd);
if (e_save != NULL)
e = e_save;
if (e != NULL)
goto finish_if_hostname;
e = gfarm_url_make_path(gfarm_url, &gfarm_file);
if (e != NULL)
goto finish_if_hostname;
/*
* replicate the program
*/
for (i = 1; i < nreplicas; i++) {
/* XXX - better strategy to select replica */
e = gfarm_file_section_replicate_from_to_internal(
gfarm_file, architecture,
s.st_mode & GFARM_S_ALLPERM, s.st_size,
hostnames[0], if_hostname, hostnames[i]);
if (e != NULL)
e_save = e;
}
e = NULL; /* there is at least on copy available. */
/* XXX - partial error case? */
free(gfarm_file);
finish_if_hostname:
free(if_hostname);
finish_hostnames:
free(hostnames);
finish_host_info:
gfarm_host_info_free_all(nhosts, hosts);
finish:
return (e);
}
int
main(int argc, char **argv)
{
gfarm_error_t e;
char *opt_domain = "";
char *opt_mount_point = NULL;
char *opt_file = NULL;
int opt_metadata_only = 0;
int opt_long_format = 0;
int opt_nhosts = 0;
int opt_write_mode = 0;
int opt_create_mode = 0;
int c, i, available_nhosts, nhosts, *ports;
struct gfarm_host_sched_info *available_hosts;
char *path, **hosts, *realpath = NULL;
if (argc >= 1)
program_name = basename(argv[0]);
e = gfarm_initialize(&argc, &argv);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", program_name,
gfarm_error_string(e));
exit(1);
}
while ((c = getopt(argc, argv, "D:LMP:cf:ln:w")) != -1) {
switch (c) {
case 'D':
opt_domain = optarg;
break;
case 'L':
gfarm_schedule_search_mode_use_loadavg();
break;
case 'M':
opt_metadata_only = 1;
break;
case 'P':
opt_mount_point = optarg;
break;
case 'c':
opt_create_mode = 1;
break;
case 'f':
opt_file = optarg;
break;
case 'l':
opt_long_format = 1;
break;
case 'n':
opt_nhosts = parse_opt_long(optarg, c, "<nhosts>");
if (opt_nhosts <= 0) {
fprintf(stderr, "%s: invalid value: -%c %d\n",
program_name, c, opt_nhosts);
usage();
}
break;
case 'w':
opt_write_mode = 1;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc != 0)
usage();
if (opt_mount_point != NULL && opt_file != NULL) {
fprintf(stderr,
"%s: -P and -f option cannot be specified at once.\n",
program_name);
usage();
}
if (opt_file != NULL) {
e = gfarm_realpath_by_gfarm2fs(opt_file, &realpath);
if (e == GFARM_ERR_NO_ERROR)
path = realpath;
else
path = opt_file;
if (opt_create_mode) {
GFS_File gf;
e = gfs_pio_create(path, GFARM_FILE_WRONLY, 0666, &gf);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: creating \"%s\": %s\n",
program_name, path, gfarm_error_string(e));
exit(1);
}
e = gfs_pio_close(gf);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr,
"%s: gfs_pio_close(\"%s\"): %s\n",
program_name, path, gfarm_error_string(e));
/* exit(1); */
}
/* NOTE: this may leave an empty file with ncopy==0 */
}
e = gfarm_schedule_hosts_domain_by_file(path,
opt_write_mode ? GFARM_FILE_RDWR : GFARM_FILE_RDONLY,
opt_domain,
&available_nhosts, &available_hosts);
} else {
path = opt_mount_point == NULL ? "." : opt_mount_point;
e = gfarm_realpath_by_gfarm2fs(path, &realpath);
if (e == GFARM_ERR_NO_ERROR)
path = realpath;
e = gfarm_schedule_hosts_domain_all(path, opt_domain,
&available_nhosts, &available_hosts);
}
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: metadata scheduling: %s\n",
program_name, gfarm_error_string(e));
exit(1);
}
nhosts = opt_nhosts > 0 ? opt_nhosts : available_nhosts;
GFARM_MALLOC_ARRAY(hosts, nhosts);
GFARM_MALLOC_ARRAY(ports, nhosts);
if (hosts == NULL || ports == NULL) {
fprintf(stderr, "%s: cannot allocate memory for %d hosts.\n",
program_name, nhosts);
exit(1);
}
if (opt_metadata_only) {
if (nhosts > available_nhosts)
nhosts = available_nhosts;
for (i = 0; i < nhosts; i++) {
hosts[i] = available_hosts[i].host;
ports[i] = available_hosts[i].port;
}
} else if (opt_write_mode) {
e = gfarm_schedule_hosts_acyclic_to_write(path,
available_nhosts, available_hosts,
&nhosts, hosts, ports);
} else {
e = gfarm_schedule_hosts_acyclic(path,
available_nhosts, available_hosts,
&nhosts, hosts, ports);
}
free(realpath);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: client side scheduling: %s\n",
program_name, gfarm_error_string(e));
exit(1);
}
for (i = 0; i < nhosts; i++) {
printf("%s", hosts[i]);
if (opt_long_format)
printf("\t%d", ports[i]);
putchar('\n');
}
free(hosts);
free(ports);
e = gfarm_terminate();
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n",
program_name, gfarm_error_string(e));
exit(1);
}
exit(0);
}
int
FUNC___OPEN(const char *path, int oflag, ...)
{
GFS_File gf;
const char *e;
char *url, *sec;
va_list ap;
mode_t mode;
int filedes;
va_start(ap, oflag);
mode = va_arg(ap, mode_t);
va_end(ap);
_gfs_hook_debug_v(fprintf(stderr,
"Hooking " S(FUNC___OPEN) "(%s, 0x%x)\n", path, oflag));
if (!gfs_hook_is_url(path, &url, &sec))
return (SYSCALL_OPEN(path, oflag, mode));
/* XXX - ROOT I/O creates a new file with O_CREAT|O_RDWR mode. */
/* XXX - FIXME */
if ((oflag & O_CREAT) != 0 || (oflag & O_TRUNC) != 0) {
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN) "(%s:%s, 0x%x, 0%o)\n",
url, sec != NULL ? sec : "(null)", oflag, mode));
if (oflag & O_TRUNC) {
/*
* Hooking open syscall does not mean to open
* an entire file but a file fragment in local and
* index file views. gfs_unlink() should not be
* called in both views.
*/
if (_gfs_hook_default_view == global_view)
gfs_unlink(url); /* XXX - FIXME */
e = gfs_pio_create(url, oflag, mode, &gf);
} else {
e = gfs_pio_open(url, oflag, &gf);
if (e == GFARM_ERR_NO_SUCH_OBJECT) /* XXX - FIXME */
e = gfs_pio_create(url, oflag, mode, &gf);
}
} else {
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN) "(%s:%s, 0x%x)\n",
url, sec != NULL ? sec : "(null)", oflag));
e = gfs_pio_open(url, oflag, &gf);
}
free(url);
if (e != NULL) {
_gfs_hook_debug(fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN) ": %s\n", e));
errno = gfarm_error_to_errno(e);
return (-1);
}
if (sec != NULL || _gfs_hook_default_view == index_view) {
if (sec != NULL) {
_gfs_hook_debug(fprintf(stderr,
"GFS: set_view_section(%s, %s)\n", url, sec));
e = gfs_pio_set_view_section(gf, sec, NULL, 0);
free(sec);
} else {
_gfs_hook_debug(fprintf(stderr,
"GFS: set_view_index(%s, %d, %d)\n", url,
_gfs_hook_num_fragments, _gfs_hook_index));
e = gfs_pio_set_view_index(gf, _gfs_hook_num_fragments,
_gfs_hook_index, NULL, 0);
}
if (e != NULL) {
_gfs_hook_debug(fprintf(stderr,
"GFS: set_view_section: %s\n", e));
gfs_pio_close(gf);
errno = gfarm_error_to_errno(e);
return (-1);
}
} else if (_gfs_hook_default_view == local_view) {
int nf = -1, np;
/*
* If the number of fragments is not the same as the
* number of parallel processes, or the file is not
* fragmented, do not change to the local file view.
*/
if (gfs_pio_get_nfragment(gf, &nf) ==
GFARM_ERR_FRAGMENT_INDEX_NOT_AVAILABLE ||
(gfs_pio_get_node_size(&np) == NULL && nf == np)) {
_gfs_hook_debug(fprintf(stderr,
"GFS: set_view_local(%s (%d, %d))\n",
url, gfarm_node, gfarm_nnode));
if ((e = gfs_pio_set_view_local(gf, 0)) != NULL) {
_gfs_hook_debug(fprintf(stderr,
"GFS: set_view_local: %s\n", e));
gfs_pio_close(gf);
errno = gfarm_error_to_errno(e);
return (-1);
}
}
}
filedes = gfs_hook_insert_gfs_file(gf);
_gfs_hook_debug(
if (filedes != -1) {
fprintf(stderr,
"GFS: Hooking " S(FUNC___OPEN) " --> %d(%d)\n",
filedes, gfs_pio_fileno(gf));
}
);