static apr_status_t webgfarm_child_exit(void* data) {
gfarm_error_t gerr = gfarm_terminate();
server_rec *s = data;
if (gerr != GFARM_ERR_NO_ERROR) {
ap_log_error(APLOG_MARK, APLOG_CRIT, 0, s, "mod_webgfarm webgfarm_child_exit gfarm_terminate fail");
}
return APR_SUCCESS;
}
int
main(int argc, char *argv[])
{
char *e, *gfarm_prefix;
extern int optind;
int c;
e = gfarm_initialize(&argc, &argv);
if (e != NULL) {
print_errmsg(progname, e);
exit(1);
}
if (!gfarm_is_active_file_system_node) {
print_errmsg(progname, "not a filesystem node");
exit(1);
}
while ((c = getopt(argc, argv, "ad")) != EOF) {
switch (c) {
case 'a':
check_all = 1;
break;
case 'd':
delete_invalid_file = 1;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (*argv) {
while (*argv)
fixurl(*argv++);
goto finish;
}
/* fix a whole spool directory. */
if (chdir(gfarm_spool_root) == 0)
gfarm_prefix = "gfarm:/";
else
gfarm_prefix = "gfarm:";
fixdir(".", gfarm_prefix);
finish:
e = gfarm_terminate();
if (e != NULL) {
print_errmsg(progname, e);
exit(1);
}
exit(0);
}
int
main(int argc, char **argv)
{
gfarm_error_t e;
int i, c, status = 0;
char *path = NULL;
if (argc > 0)
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, "h?")) != -1) {
switch (c) {
case 'h':
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc <= 0)
usage();
for (i = 0; i < argc; i++) {
e = gfarm_realpath_by_gfarm2fs(argv[i], &path);
if (e == GFARM_ERR_NO_ERROR)
argv[i] = path;
e = gfs_rmdir(argv[i]);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s: %s\n",
program_name, argv[i], gfarm_error_string(e));
status = 1;
}
free(path);
}
e = gfarm_terminate();
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", program_name,
gfarm_error_string(e));
status = 1;
}
return (status);
}
int
main(int argc, char *argv[])
{
char *e, *gfarm_prefix;
extern int optind;
int c;
e = gfarm_initialize(&argc, &argv);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", progname, e);
}
while ((c = getopt(argc, argv, "ad")) != EOF) {
switch (c) {
case 'a':
check_all = 1;
break;
case 'd':
delete_invalid_file = 1;
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc > 0) {
while (argc-- > 0 && fixurl(*argv++) == 0);
goto finish;
}
/* fix a whole spool directory. */
if (chdir(gfarm_spool_root) == 0)
gfarm_prefix = "gfarm:/";
else
gfarm_prefix = "gfarm:";
fixdir(".", gfarm_prefix);
finish:
e = gfarm_terminate();
if (e != NULL) {
fprintf(stderr, "%s: %s\n", progname, e);
}
exit(0);
}
int
main(int argc, char *argv[])
{
char *pathname;
int nfrags;
char *e;
extern int optind;
int c;
enum { add, delete } mode = add;
e = gfarm_initialize(&argc, &argv);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", progname, e);
}
while ((c = getopt(argc, argv, "d")) != EOF) {
switch (c) {
case 'd':
mode = delete;
break;
default:
usage();
exit(1);
}
}
argc -= optind;
argv += optind;
if (argc > 0)
pathname = argv[0];
else {
fprintf(stderr, "%s: too few arguments\n", progname);
usage();
exit(1);
}
--argc;
++argv;
switch (mode) {
case add:
if (argc == 1)
nfrags = atoi(argv[0]);
else {
usage();
exit(1);
}
e = gfarm_path_info_set_from_file(pathname, nfrags);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", pathname, e);
exit(1);
}
break;
case delete:
e = gfarm_path_info_remove_all(pathname);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", pathname, e);
exit(1);
}
break;
}
e = gfarm_terminate();
if (e != NULL) {
fprintf(stderr, "%s: %s\n", pathname, e);
}
exit(0);
}
int
main(int argc, char **argv)
{
gfarm_error_t e;
int c, status = 0;
int opt_group = 0; /* default: users list */
char *name = NULL, *realpath = NULL;
const char *path = ".";
if (argc > 0)
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, "P:gh?")) != -1) {
switch (c) {
case 'P':
path = optarg;
break;
case 'g':
opt_group = 1;
break;
case 'h':
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (gfarm_realpath_by_gfarm2fs(path, &realpath) == GFARM_ERR_NO_ERROR)
path = realpath;
if ((e = gfm_client_connection_and_process_acquire_by_path(
path, &gfm_server)) != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: metadata server for \"%s\": %s\n",
program_name, path, gfarm_error_string(e));
status = 1;
goto terminate;
}
if (argc > 0)
name = argv[0];
if (name) {
if (opt_group)
e = usage_group_one(name);
else
e = usage_user_one(name);
} else {
if (opt_group)
e = usage_group_all();
else
e = usage_user_all();
}
if (e != GFARM_ERR_NO_ERROR)
status = 1;
if (e == GFARM_ERR_OPERATION_NOT_PERMITTED)
fprintf(stderr, "%s: %s\n", program_name,
gfarm_error_string(e));
gfm_client_connection_free(gfm_server);
terminate:
free(realpath);
e = gfarm_terminate();
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", program_name,
gfarm_error_string(e));
status = 1;
}
return (status);
}
int
main(int argc, char **argv)
{
int argc_save = argc;
char **argv_save = argv;
gfarm_error_t e, e_save = GFARM_ERR_NO_ERROR;
int i, n, ch, opt_recursive = 0;
gfarm_stringlist paths;
gfs_glob_t types;
if (argc >= 1)
program_name = basename(argv[0]);
while ((ch = getopt(argc, argv, "rR?")) != -1) {
switch (ch) {
case 'r':
case 'R':
opt_recursive = 1;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
e = gfarm_initialize(&argc_save, &argv_save);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", program_name,
gfarm_error_string(e));
exit(1);
}
if (argc == 0) {
usage();
}
e = gfarm_stringlist_init(&paths);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", program_name,
gfarm_error_string(e));
exit(EXIT_FAILURE);
}
e = gfs_glob_init(&types);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", program_name,
gfarm_error_string(e));
exit(EXIT_FAILURE);
}
for (i = 0; i < argc; i++)
gfs_glob(argv[i], &paths, &types);
gfs_glob_free(&types);
n = gfarm_stringlist_length(&paths);
for (i = 0; i < n; i++) {
char *p = gfarm_stringlist_elem(&paths, i);
struct gfs_stat st;
if ((e = gfs_stat(p, &st)) != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", p, gfarm_error_string(e));
} else {
if (GFARM_S_ISREG(st.st_mode))
e = display_replica_catalog(p, &st, NULL);
else if (opt_recursive)
e = gfarm_foreach_directory_hierarchy(
display_replica_catalog, display_name,
NULL, p, NULL);
else
fprintf(stderr, "%s: not a file\n", p);
gfs_stat_free(&st);
if (e_save == GFARM_ERR_NO_ERROR)
e_save = e;
}
}
gfarm_stringlist_free_deeply(&paths);
e = gfarm_terminate();
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", program_name,
gfarm_error_string(e));
exit(1);
}
return (e_save == GFARM_ERR_NO_ERROR ? 0 : 1);
}
int
main(int argc, char *argv[])
{
char *src_hostfile = NULL, *dst_hostfile = NULL;
gfarm_stringlist paths;
gfs_glob_t types;
int mode_src_ch = 0, mode_dst_ch = 0, parallel = -1;
int i, ch;
gfarm_error_t e;
const char *errmsg, *errmsg2 = NULL;
struct gfrep_arg gfrep_arg;
struct flist flist;
if (argc >= 1)
program_name = basename(argv[0]);
memset(&gfrep_arg, 0, sizeof(gfrep_arg));
memset(&flist, 0, sizeof(flist));
flist.src_domain = "";
flist.dst_domain = "";
e = gfarm_initialize(&argc, &argv);
error_check(e);
#ifdef _OPENMP
while ((ch = getopt(argc, argv, "h:j:mnqvxS:D:H:N:?")) != -1) {
#else
while ((ch = getopt(argc, argv, "h:mnqvxS:D:H:N:?")) != -1) {
#endif
switch (ch) {
case 'h':
src_hostfile = optarg;
conflict_check(&mode_src_ch, ch);
break;
#ifdef _OPENMP
case 'j':
parallel = strtol(optarg, NULL, 0);
break;
#endif
case 'm':
act = &migrate_mode;
break;
case 'n':
opt_noexec = 1;
break;
case 'q':
opt_quiet = 1;
break;
case 'v':
opt_verbose = 1;
break;
case 'x':
opt_remove = 1;
break;
case 'S':
flist.src_domain = optarg;
conflict_check(&mode_src_ch, ch);
break;
case 'D':
flist.dst_domain = optarg;
conflict_check(&mode_dst_ch, ch);
break;
case 'H':
dst_hostfile = optarg;
conflict_check(&mode_dst_ch, ch);
break;
case 'N':
opt_nrep = strtol(optarg, NULL, 0);
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
/* make writing-to-stderr atomic, for GfarmFS-FUSE log output */
setvbuf(stderr, NULL, _IOLBF, 0);
if (!opt_quiet) {
printf("constructing file list...");
fflush(stdout);
}
e = gfarm_stringlist_init(&paths);
if (e == GFARM_ERR_NO_ERROR) {
e = gfs_glob_init(&types);
if (e == GFARM_ERR_NO_ERROR) {
for (i = 0; i < argc; i++)
gfs_glob(argv[i], &paths, &types);
gfs_glob_free(&types);
}
}
error_check(e);
e = gfarm_list_init(&flist.slist);
error_check(e);
e = gfarm_list_init(&flist.dlist);
error_check(e);
flist.srchash = gfarm_hash_table_alloc(HOSTHASH_SIZE,
gfarm_hash_casefold, gfarm_hash_key_equal_casefold);
if (flist.srchash == NULL)
error_check(GFARM_ERR_NO_MEMORY);
e = create_hosthash_from_file(src_hostfile,
HOSTHASH_SIZE, &flist.src_hosthash);
error_check(e);
e = create_hosthash_from_file(dst_hostfile,
HOSTHASH_SIZE, &flist.dst_hosthash);
error_check(e);
for (i = 0; i < gfarm_stringlist_length(&paths); i++) {
char *file = gfarm_stringlist_elem(&paths, i), *realpath = NULL;
e = gfarm_realpath_by_gfarm2fs(file, &realpath);
if (e == GFARM_ERR_NO_ERROR)
file = realpath;
e = gfarm_foreach_directory_hierarchy(
create_filelist, NULL, NULL, file, &flist);
free(realpath);
if (e != GFARM_ERR_NO_ERROR)
break;
}
gfarm_stringlist_free_deeply(&paths);
error_check(e);
if (!opt_quiet)
printf(" done\n");
if (opt_verbose) {
printf("files to be replicated\n");
print_file_list(&flist.slist);
}
if (opt_verbose && opt_remove) {
printf("files having too many replicas\n");
print_file_list(&flist.dlist);
}
if (gfarm_list_length(&flist.slist) <= 0
&& (!opt_remove || gfarm_list_length(&flist.dlist) <= 0))
exit(0); /* no file */
/* replicate files */
e = gfarm_hash_to_string_array(
flist.srchash, &gfrep_arg.nsrc, &gfrep_arg.src);
error_check(e);
gfarm_hash_table_free(flist.srchash);
if (!opt_quiet) {
printf("investigating hosts...");
fflush(stdout);
}
e = create_hostlist_by_domain_and_hash(
gfarm_list_length(&flist.slist) > 0 ?
gfarm_list_elem(&flist.slist, 0) :
gfarm_list_elem(&flist.dlist, 0),
flist.dst_domain, flist.dst_hosthash,
&gfrep_arg.ndst, &gfrep_arg.dst, &gfrep_arg.dst_port);
error_check(e);
if (!opt_quiet)
printf(" done\n");
errmsg = pfor_list(act, &flist.slist, parallel, &gfrep_arg);
gfarm_list_free(&flist.slist);
/* remove file replicas */
if (opt_remove)
errmsg2 = pfor_list(
&remove_mode, &flist.dlist, parallel, &gfrep_arg);
gfarm_list_free(&flist.dlist);
if (errmsg == NULL)
errmsg = errmsg2;
if (errmsg != NULL)
fprintf(stderr, "%s\n", errmsg), exit(EXIT_FAILURE);
gfarm_strings_free_deeply(gfrep_arg.nsrc, gfrep_arg.src);
gfarm_strings_free_deeply(gfrep_arg.ndst, gfrep_arg.dst);
free(gfrep_arg.dst_port);
e = gfarm_terminate();
error_check(e);
return (0);
}
int
main(int argc, char **argv)
{
gfarm_int32_t interleave_factor = 0;
gfarm_int32_t ndivisions = 1;
int recv_stripe_sync = 0;
int send_stripe_sync = 0;
int file_sync_stripe = 0;
struct xxx_connection *from_frontend, *to_frontend;
struct xxx_connection *from_server, *to_server;
char *e, *src_host, *my_canonical_name;
char **gfrcmd_paths, **gfrep_backend_server_paths;
int c, i, n, replication_method_save;
gfarm_stringlist files, sections;
struct gfarm_path_info *path_infos;
gfarm_int32_t *results;
struct sockaddr server_addr;
e = gfarm_initialize(&argc, &argv);
if (e != NULL) {
fprintf(stderr, "%s: gfarm_initialize on %s: %s\n",
program_name, my_name, e);
fatal();
}
while ((c = getopt(argc, argv, "i:n:rsS:")) != -1) {
switch (c) {
case 'i':
interleave_factor = atoi(optarg);
break;
case 'n':
ndivisions = atoi(optarg);
break;
case 'r':
recv_stripe_sync = 1;
break;
case 's':
send_stripe_sync = 1;
break;
case 'S':
file_sync_stripe = atoi(optarg);
break;
default:
fprintf(stderr, "%s: unknown option -%c\n",
program_name, c);
usage();
/*NOTREACHED*/
}
}
argc -= optind;
argv += optind;
my_name = gfarm_host_get_self_name();
if (argc != 1) {
fprintf(stderr, "%s: missing server name argument on %s\n",
program_name, my_name);
usage();
/*NOTREACHED*/
}
src_host = argv[0];
e = gfarm_host_get_canonical_self_name(&my_canonical_name);
if (e != NULL) {
fprintf(stderr, "%s: host %s isn't a filesystem node: %s\n",
program_name, my_name, e);
fatal();
}
replication_method_save = gfarm_replication_get_method();
gfarm_replication_set_method(GFARM_REPLICATION_BOOTSTRAP_METHOD);
e = gfarm_url_program_deliver(gfrcmd_url,
1, &my_canonical_name, &gfrcmd_paths);
if (e != NULL) {
fprintf(stderr, "%s: cannot deliver %s to host %s on %s: %s\n",
program_name, gfrcmd_url, my_canonical_name, my_name, e);
fatal();
}
e = gfarm_url_program_deliver(gfrep_backend_server,
1, &src_host, &gfrep_backend_server_paths);
if (e != NULL) {
fprintf(stderr, "%s: cannot deliver %s to host %s on %s: %s\n",
program_name, gfrep_backend_server, src_host, my_name, e);
fatal();
}
gfarm_replication_set_method(replication_method_save);
e = gfs_client_rep_backend_invoke(
src_host, gfrcmd_paths[0], gfrep_backend_server_paths[0], NULL,
GFS_CLIENT_REP_ALGORITHM_LATEST,
ndivisions, interleave_factor, 0, send_stripe_sync, 0,
program_name,
&from_server, &to_server, &backend);
if (e != NULL)
fatal();
e = gfarm_host_address_get(src_host, 0, &server_addr, NULL);
if (e != NULL) {
fprintf(stderr, "%s: %s: %s\n", program_name, src_host, e);
fatal();
}
e = gfarm_netparam_config_get_long(&gfarm_netparam_file_sync_rate,
src_host, (struct sockaddr *)&server_addr, &file_sync_rate);
if (e != NULL) {/* shouldn't happen */
fprintf(stderr,
"%s: get netparam file_sync_rate on %s (%s): %s\n",
program_name, my_name, src_host, e);
fatal();
}
/* XXX read-only connection */
e = xxx_fd_connection_new(STDIN_FILENO, &from_frontend);
if (e != NULL) {
fprintf(stderr, "%s: %s for stdin\n", program_name, e);
fatal();
}
/* XXX write-only connection */
e = xxx_fd_connection_new(STDOUT_FILENO, &to_frontend);
if (e != NULL) {
fprintf(stderr, "%s: %s for stdout\n", program_name, e);
fatal();
}
e = gfs_client_rep_filelist_receive(from_frontend,
&n, &files, §ions, program_name);
if (e != NULL)
fatal();
e = gfs_client_rep_filelist_send(src_host, to_server, program_name,
n, &files, §ions);
if (e != NULL)
fatal();
results = malloc(sizeof(*results) * n);
if (results == NULL) {
fprintf(stderr, "%s: no memory for %d ints on %s\n",
program_name, n, my_name);
fatal();
}
/* make current directory == spool_root */
if (chdir(gfarm_spool_root) == -1) {
fprintf(stderr, "%s: chdir(%s) on %s: %s\n",
program_name, gfarm_spool_root, my_name,
e);
fatal();
}
path_infos = malloc(sizeof(*path_infos) * n);
if (results == NULL) {
fprintf(stderr, "%s: no memory for %d path_info on %s\n",
program_name, n, my_name);
fatal();
}
for (i = 0; i < n; i++) {
e = gfarm_path_info_get(gfarm_stringlist_elem(&files, i),
&path_infos[i]);
results[i] = e == NULL ? GFS_ERROR_NOERROR :
gfs_string_to_proto_error(e);
}
umask(0); /* don't mask, just use the 3rd parameter of open(2) */
session(src_host, &server_addr, from_server, to_server,
my_canonical_name,
ndivisions, interleave_factor, file_sync_stripe, recv_stripe_sync,
n, &files, §ions, path_infos, results);
#ifdef HACK_FOR_BWC
/*
* If this program fails with fatal(), or is killed by a signal,
* this metadata update isn't executed. (So, #undef HACK_FOR_BWC)
*/
for (i = 0; i < n; i++) {
char *file = gfarm_stringlist_elem(&files, i);
char *section = gfarm_stringlist_elem(§ions, i);
struct gfarm_file_section_copy_info fci;
if (results[i] == GFS_ERROR_NOERROR) {
e = gfarm_file_section_copy_info_set(file, section,
my_canonical_name, &fci);
if (e != NULL)
results[i] = gfs_string_to_proto_error(e);
}
}
#endif
for (i = 0; i < n; i++)
xxx_proto_send(to_frontend, "i", results[i]);
xxx_proto_flush(to_frontend);
e = gfarm_terminate();
if (e != NULL) {
fprintf(stderr, "%s: gfarm_terminate on %s: %s\n",
program_name, my_name, e);
fatal();
}
return (0);
}
int
main(int argc, char *argv[])
{
char *src = NULL, *dst = NULL, *f, c;
struct gfarm_host_info sinfo, dinfo;
gfarm_error_t e;
if (argc > 0)
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(EXIT_FAILURE);
}
while ((c = getopt(argc, argv, "d:s:h?")) != -1) {
switch (c) {
case 'd':
dst = optarg;
break;
case 's':
src = optarg;
break;
case 'h':
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (dst == NULL)
usage();
if (src != NULL) {
e = gfarm_host_info_get_by_name_alias(src, &sinfo);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", src,
gfarm_error_string(e));
exit(EXIT_FAILURE);
}
}
e = gfarm_host_info_get_by_name_alias(dst, &dinfo);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", dst, gfarm_error_string(e));
exit(EXIT_FAILURE);
}
f = *argv;
e = gfs_replicate_from_to(f, src, sinfo.port, dst, dinfo.port);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", f, gfarm_error_string(e));
exit(EXIT_FAILURE);
}
if (src != NULL)
gfarm_host_info_free(&sinfo);
gfarm_host_info_free(&dinfo);
e = gfarm_terminate();
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n",
program_name, gfarm_error_string(e));
exit(EXIT_FAILURE);
}
return (0);
}
int
main(int argc, char **argv)
{
char *e, *canonic_path;
int i;
if (argc <= 1)
usage();
program_name = basename(argv[0]);
e = gfarm_initialize(&argc, &argv);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(1);
}
for (i = 1; i < argc; i++) {
char *e;
struct args a;
struct gfarm_path_info pi;
GFS_Dir dir;
struct gfs_dirent *entry;
int nhosts_succeed;
e = gfarm_url_make_path(argv[i], &canonic_path);
/* We permit missing gfarm: prefix here as a special case */
if (e == GFARM_ERR_GFARM_URL_PREFIX_IS_MISSING)
e = gfarm_canonical_path(argv[i],
&canonic_path);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
continue;
}
e = gfarm_path_info_get(canonic_path, &pi);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(1);
}
if (!GFARM_S_ISDIR(pi.status.st_mode)) {
fprintf(stderr, "%s: %s: %s\n", program_name, argv[i],
GFARM_ERR_NOT_A_DIRECTORY);
free(canonic_path);
gfarm_path_info_free(&pi);
continue;
}
gfarm_path_info_free(&pi);
e = gfs_opendir(argv[i], &dir);
if (e != NULL) {
fprintf(stderr, "%s: %s: %s\n", program_name, argv[i],
e);
exit(1);
}
e = gfs_readdir(dir, &entry);
if (e != NULL) {
fprintf(stderr, "%s: %s: %s\n", program_name, argv[i],
e);
exit(1);
}
if (entry != NULL) {
fprintf(stderr, "%s: %s: %s\n", program_name, argv[i],
"directory not empty");
free(canonic_path);
continue;
}
a.path = canonic_path;
e = gfs_client_apply_all_hosts(gfrmdir, &a, program_name,
&nhosts_succeed);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(1);
}
e = gfarm_path_info_remove(canonic_path);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(1);
}
free(canonic_path);
}
e = gfarm_terminate();
return (0);
}
int
main(int argc, char **argv)
{
char *e, *canonic_path;
int i, c;
extern int optind;
char *user;
if (argc <= 1)
usage();
program_name = basename(argv[0]);
while ((c = getopt(argc, argv, "h")) != EOF) {
switch (c) {
case 'h':
default:
usage();
}
}
argc -= optind;
argv += optind;
e = gfarm_initialize(&argc, &argv);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(1);
}
user = gfarm_get_global_username();
if (user == NULL) {
fprintf(stderr, "%s:%s%s\n", program_name,
"programming error, gfarm library isn't properly ",
"initialized");
exit(1);
}
for (i = 0; i < argc; i++) {
struct gfarm_path_info pi;
struct timeval now;
e = gfarm_url_make_path_for_creation(argv[i], &canonic_path);
/* We permit missing gfarm: prefix here as a special case */
if (e == GFARM_ERR_GFARM_URL_PREFIX_IS_MISSING)
e = gfarm_canonical_path_for_creation(argv[i],
&canonic_path);
if (e != NULL) {
fprintf(stderr, "%s: %s: %s\n", program_name, argv[i],
e);
exit(1);
}
if (gfarm_path_info_get(canonic_path, &pi) == 0) {
fprintf(stderr, "%s: %s: %s\n",
program_name, argv[i],
GFARM_ERR_ALREADY_EXISTS);
gfarm_path_info_free(&pi);
continue;
}
gettimeofday(&now, NULL);
pi.pathname = canonic_path;
pi.status.st_mode = (GFARM_S_IFDIR | 0755);
pi.status.st_user = user;
pi.status.st_group = "*"; /* XXX for now */
pi.status.st_atimespec.tv_sec =
pi.status.st_mtimespec.tv_sec =
pi.status.st_ctimespec.tv_sec = now.tv_sec;
pi.status.st_atimespec.tv_nsec =
pi.status.st_mtimespec.tv_nsec =
pi.status.st_ctimespec.tv_nsec = now.tv_usec * 1000;
pi.status.st_size = 0;
pi.status.st_nsections = 0;
e = gfarm_path_info_set(canonic_path, &pi);
if (e != NULL) {
fprintf(stderr, "%s: %s: %s\n", program_name, argv[i],
e);
exit(1);
}
free(canonic_path);
}
e = gfarm_terminate();
return (0);
}
int
main(int argc, char **argv)
{
int argc_save = argc;
char **argv_save = argv;
gfarm_error_t e, e_save = GFARM_ERR_NO_ERROR;
char opt_operation = '\0'; /* default operation */
int opt_concurrency = DEFAULT_CONCURRENCY;
int opt_alter_aliases = 0;
char *opt_architecture = NULL;
char *opt_domainname = NULL;
long opt_ncpu = 0;
int opt_port = 0, opt_flags = -1;
int opt_plain_order = 0; /* i.e. do not sort */
int opt_sort_by_loadavg = 0;
int i, c, opt_use_metadb = 1;
char *s;
if (argc > 0)
program_name = basename(argv[0]);
while ((c = getopt(argc, argv, "AD:HLMPUa:cdf:ij:lmn:p:ruv?")) != -1) {
switch (c) {
case 'A':
opt_alter_aliases = 1;
break;
case 'L':
opt_sort_by_loadavg = 1;
break;
case 'M':
case 'H':
case 'R':
case 'c':
case 'd':
case 'l':
case 'm':
if (opt_operation != '\0' && opt_operation != c)
inconsistent_option(opt_operation, c);
opt_operation = c;
break;
case 'a':
opt_architecture = optarg;
s = validate_architecture(opt_architecture);
if (s != NULL) {
fprintf(stderr, "%s: "
"invalid character '%c' in \"-a %s\"\n",
program_name, *s, opt_architecture);
exit(1);
}
break;
case 'D':
opt_domainname = optarg;
s = validate_hostname(opt_domainname);
if (s != NULL) {
fprintf(stderr, "%s: "
"invalid character '%c' in \"-a %s\"\n",
program_name, *s, opt_domainname);
exit(1);
}
break;
case 'i':
opt_resolv_addr = resolv_addr_without_address_use;
break;
case 'j':
opt_concurrency = parse_opt_long(optarg,
c, "<concurrency>");
if (opt_concurrency <= 0) {
fprintf(stderr, "%s: invalid value: -%c %d\n",
program_name, c, opt_concurrency);
usage();
}
break;
case 'f':
opt_flags = parse_opt_long(optarg, c, "<flags>");
break;
case 'n':
opt_ncpu = parse_opt_long(optarg, c, "<ncpu>");
break;
case 'p':
opt_port = parse_opt_long(optarg, c, "<port>");
break;
case 'r':
output_sort_reverse = 1;
break;
case 'U':
opt_udp_only = 1;
break;
case 'u':
opt_plain_order = 1;
break;
case 'v':
opt_verbose = 1;
break;
case '?':
usage();
}
}
argc -= optind;
argv += optind;
switch (opt_operation) {
case OP_CREATE_ENTRY:
if (opt_architecture == NULL) {
fprintf(stderr, "%s: missing -a <architecture>\n",
program_name);
usage();
}
if (opt_ncpu == 0)
opt_ncpu = 1;
if (opt_flags == -1)
opt_flags = 0;
/* opt_alter_aliases is meaningless, but allowed */
break;
case OP_REGISTER_DB:
case OP_DELETE_ENTRY:
if (opt_architecture != NULL)
invalid_option('a');
if (opt_domainname != NULL)
invalid_option('D');
/* fall through */
case OP_NODENAME:
case OP_LIST_GFSD_INFO:
case OP_LIST_LONG:
case OP_DUMP_METADB:
if (opt_ncpu != 0)
invalid_option('n');
if (opt_alter_aliases)
invalid_option('A');
break;
case OP_MODIFY_ENTRY:
if (opt_domainname != NULL)
invalid_option('D');
break;
default:
;
}
for (i = 0; i < argc; i++) {
s = validate_hostname(argv[i]);
if (s != NULL) {
fprintf(stderr, "%s: "
"invalid character '%c' in hostname \"%s\"\n",
program_name, *s, argv[i]);
exit(1);
}
}
e = gfarm_initialize(&argc_save, &argv_save);
if (opt_operation == OP_LIST_GFSD_INFO && argc > 0 &&
opt_resolv_addr == resolv_addr_without_address_use) {
/*
* An implicit feature to access gfsd directly
* without having working gfmd.
* e.g. gfhost -Hi <hostname>
*
* XXX should describe this in the manual?
* or use explicit and different option?
*/
opt_use_metadb = 0;
opt_resolv_addr = resolv_addr_without_metadb;
} else if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", program_name,
gfarm_error_string(e));
exit(1);
}
switch (opt_operation) {
case OP_CREATE_ENTRY:
if (argc > 0) {
if (opt_port == 0) {
fprintf(stderr, "%s: option -p <port> is "
"mandatory with -c\n", program_name);
usage();
}
e_save = add_host(argv[0], opt_port, &argv[1],
opt_architecture, opt_ncpu, opt_flags);
if (e_save != GFARM_ERR_NO_ERROR)
fprintf(stderr, "%s: %s: %s\n", program_name,
argv[0], gfarm_error_string(e_save));
}
break;
case OP_MODIFY_ENTRY:
if (argc > 0) {
e_save = gfarm_modify_host(argv[0], opt_port, &argv[1],
opt_architecture, opt_ncpu, opt_flags,
!opt_alter_aliases);
if (e_save != GFARM_ERR_NO_ERROR)
fprintf(stderr, "%s: %s: %s\n", program_name,
argv[0], gfarm_error_string(e_save));
}
break;
case OP_DELETE_ENTRY:
for (i = 0; i < argc; i++) {
e = gfm_client_host_info_remove(gfarm_metadb_server,
argv[i]);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", argv[i],
gfarm_error_string(e));
if (e_save == GFARM_ERR_NO_ERROR)
e_save = e;
}
}
break;
case OP_REGISTER_DB:
if (argc > 0) {
fprintf(stderr, "%s: too many argument: %s\n",
program_name, argv[0]);
exit(1);
}
e_save = register_db();
break;
case OP_LIST_GFSD_INFO:
e = paraccess_list(opt_concurrency, opt_udp_only,
opt_architecture, opt_domainname, opt_port,
opt_plain_order, opt_sort_by_loadavg,
opt_use_metadb, argc, argv,
request_gfsd_info, callback_gfsd_info);
break;
case OP_NODENAME:
e = paraccess_list(opt_concurrency, opt_udp_only,
opt_architecture, opt_domainname, opt_port,
opt_plain_order, opt_sort_by_loadavg,
opt_use_metadb, argc, argv,
request_nodename, callback_nodename);
break;
case OP_LIST_LONG:
e = paraccess_list(opt_concurrency, opt_udp_only,
opt_architecture, opt_domainname, opt_port,
opt_plain_order, opt_sort_by_loadavg,
opt_use_metadb, argc, argv,
request_long_format, callback_long_format);
break;
case OP_DUMP_METADB:
if (argc == 0) {
e_save = list_all(opt_architecture, opt_domainname,
print_host_info, NULL);
} else {
e_save = list(argc, argv, print_host_info, NULL);
}
break;
}
e = gfarm_terminate();
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", program_name,
gfarm_error_string(e));
exit(1);
}
exit(e_save == GFARM_ERR_NO_ERROR ? 0 : 1);
}
int
main(int argc, char *argv[])
{
gfarm_error_t e;
char op = OP_GROUPNAME, *groupname;
int c;
const char *path = ".";
char *realpath = NULL;
e = gfarm_initialize(&argc, &argv);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: gfarm_initialize: %s\n",
program_name, gfarm_error_string(e));
exit(1);
}
while ((c = getopt(argc, argv, "P:cdlm?")) != -1) {
switch (c) {
case 'P':
path = optarg;
break;
case OP_CREATE_GROUP:
case OP_DELETE_GROUP:
case OP_MODIFY_GROUP:
case OP_LIST_LONG:
op = c;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (gfarm_realpath_by_gfarm2fs(path, &realpath) == GFARM_ERR_NO_ERROR)
path = realpath;
if ((e = gfm_client_connection_and_process_acquire_by_path(path,
&gfm_server)) != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: metadata server for \"%s\": %s\n",
program_name, path, gfarm_error_string(e));
exit(1);
}
free(realpath);
switch (op) {
case OP_GROUPNAME:
case OP_LIST_LONG:
if (argc == 0)
e = list_all(op);
else
e = list(op, argc, argv);
break;
case OP_CREATE_GROUP:
case OP_MODIFY_GROUP:
if (argc < 1)
usage();
groupname = *argv++;
--argc;
e = create_group(op, groupname, argc, argv);
break;
case OP_DELETE_GROUP:
if (argc != 1)
usage();
e = delete_group(*argv);
break;
}
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n",
program_name, gfarm_error_string(e));
exit(1);
}
gfm_client_connection_free(gfm_server);
e = gfarm_terminate();
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: gfarm_terminate: %s\n",
program_name, gfarm_error_string(e));
exit(1);
}
exit(0);
}
int
main(int argc, char **argv)
{
extern char *optarg;
extern int optind;
int argc_save = argc;
char **argv_save = argv;
char *e, *section = NULL;
int i, ch, error = 0;
gfarm_stringlist paths;
gfs_glob_t types;
int argc_expanded;
if (argc >= 1)
program_name = basename(argv[0]);
while ((ch = getopt(argc, argv, "I:")) != -1) {
switch (ch) {
case 'I':
section = optarg;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
e = gfarm_initialize(&argc_save, &argv_save);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(1);
}
if (argc == 0) {
usage();
}
e = gfarm_stringlist_init(&paths);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(EXIT_FAILURE);
}
e = gfs_glob_init(&types);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(EXIT_FAILURE);
}
for (i = 0; i < argc; i++)
gfs_glob(argv[i], &paths, &types);
argc_expanded = gfarm_stringlist_length(&paths);
for (i = 0; i < argc_expanded; i++) {
char *p = gfarm_stringlist_elem(&paths, i);
if (argc_expanded > 1)
printf("%s:\n", p);
if (display_replica_catalog_section(p, section) != NULL)
error = 1;
if (argc_expanded > 1 && i < argc_expanded - 1)
printf("\n");
}
gfs_glob_free(&types);
gfarm_stringlist_free_deeply(&paths);
e = gfarm_terminate();
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(1);
}
return (error);
}
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
main(int argc, char *argv[])
{
char *gfarm_url, *node_index = NULL;
char *hostname = NULL, **auto_hosts = NULL, *domainname = NULL, *e;
int total_nodes = -1, c, auto_index = 0;
extern char *optarg;
extern int optind;
e = gfarm_initialize(&argc, &argv);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(1);
}
/* Command options */
while ((c = getopt(argc, argv, "a:fh:D:I:N:")) != -1) {
switch (c) {
case 'I':
case 'a':
node_index = optarg;
break;
case 'N':
total_nodes = strtol(optarg, NULL, 0);
break;
case 'h':
hostname = optarg;
break;
case 'D':
domainname = optarg;
break;
case 'f':
opt_force = 1;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc == 0) {
fprintf(stderr, "%s: missing a local filename\n",
program_name);
usage();
}
if (argc == 1) {
fprintf(stderr, "%s: missing a Gfarm URL\n",
program_name);
usage();
}
if ((argc > 2 || hostname == NULL)
&& (argc > 1 && total_nodes < 0 && node_index == NULL)) {
total_nodes = argc - 1;
auto_index = 1;
if (hostname != NULL)
fprintf(stderr, "%s: warning: -h option is ignored\n",
program_name);
auto_hosts = malloc(total_nodes * sizeof(char *));
if (auto_hosts != NULL) {
if (domainname != NULL)
e = gfarm_schedule_search_idle_by_domainname(
domainname, total_nodes, auto_hosts);
else
e = gfarm_schedule_search_idle_by_all(
total_nodes, auto_hosts);
if (e != NULL) {
free(auto_hosts);
auto_hosts = NULL;
}
}
}
gfarm_url = argv[argc - 1];
while (--argc) {
char index_str[GFARM_INT32STRLEN + 1];
/* XXX - need to register in parallel? */
if (auto_index) {
sprintf(index_str, "%d", total_nodes - argc);
node_index = index_str;
if (auto_hosts != NULL)
hostname = auto_hosts[total_nodes - argc];
}
if (gfarm_register_file(gfarm_url, node_index, hostname,
total_nodes, *argv++, auto_index))
break;
}
if (auto_hosts != NULL)
gfarm_strings_free_deeply(total_nodes, auto_hosts);
e = gfarm_terminate();
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(1);
}
exit(0);
}
static const char *
pfor(struct action *act, int nfinfo, struct file_info **finfo,
int nthreads, struct gfrep_arg *arg)
{
int i, pi, tnum, nth, nerr = 0;
gfarm_error_t e;
int ndst = arg->ndst, nsrc = arg->nsrc;
const char *errmsg;
if (ndst <= 0)
return ("no destination node");
if (nsrc <= 0)
return ("no source node");
if (ndst < opt_nrep)
return ("not enough number of destination nodes");
if (nfinfo <= 0)
return (NULL); /* no file */
/* sort 'sinfo' in descending order wrt file size */
qsort(finfo, nfinfo, sizeof(*finfo), filesizecmp_inv);
if (nthreads <= 0) {
nthreads = nfinfo;
if (ndst < nthreads)
nthreads = ndst;
if (nsrc < nthreads)
nthreads = nsrc;
}
if (opt_verbose) {
print_gfrep_arg(arg);
printf("files: %d\n", nfinfo);
#ifdef _OPENMP
printf("parallel %s in %d threads\n", act->msg, nthreads);
#endif
}
omp_set_num_threads(nthreads);
#pragma omp parallel reduction(+:nerr) private(pi, tnum, nth)
{
pi = 0;
tnum = omp_get_thread_num();
nth = omp_get_num_threads();
#pragma omp for schedule(dynamic)
for (i = 0; i < nfinfo; ++i) {
struct timeval t1, t2;
double t;
struct file_info *fi = finfo[i];
#ifdef LIBGFARM_NOT_MT_SAFE
pid_t pid;
int s, rv;
#endif
if (opt_noexec || !opt_quiet)
printf("%s\n", fi->pathname);
if (opt_verbose)
print_file_info(fi);
if (tnum + pi * nth >= ndst)
pi = 0;
#ifdef LIBGFARM_NOT_MT_SAFE
pid = fork();
if (pid == 0) {
e = gfarm_terminate();
if (e == GFARM_ERR_NO_ERROR)
e = gfarm_initialize(NULL, NULL);
if (e != GFARM_ERR_NO_ERROR) {
errmsg = gfarm_error_string(e);
goto skip_replication;
}
#endif
if (opt_verbose)
gettimeofday(&t1, NULL);
if (!opt_noexec) {
e = action(act, tnum, nth, pi, fi, arg);
errmsg = gfarm_error_string(e);
} else {
e = GFARM_ERR_NO_ERROR;
errmsg = gfarm_error_string(e);
}
if (opt_verbose && e == GFARM_ERR_NO_ERROR) {
gettimeofday(&t2, NULL);
t = gfarm_timerval_sub(&t2, &t1);
printf("%s: %f sec %f MB/sec\n",
fi->pathname, t,
fi->filesize / t / 1024 / 1024);
}
#ifdef LIBGFARM_NOT_MT_SAFE
skip_replication:
#endif
if (e != GFARM_ERR_NO_ERROR) {
#ifndef LIBGFARM_NOT_MT_SAFE
++nerr;
#endif
fprintf(stderr, "%s: %s\n",
fi->pathname, errmsg);
}
#ifdef LIBGFARM_NOT_MT_SAFE
fflush(stdout);
sync();
_exit(e == GFARM_ERR_NO_ERROR ? 0 : 1);
}
while ((rv = waitpid(pid, &s, 0)) == -1 && errno == EINTR)
;
if (rv == -1 || (WIFEXITED(s) && WEXITSTATUS(s) != 0))
++nerr;
#endif
++pi;
}
}
return (nerr == 0 ? NULL : "error happens during operations");
}
int
main(int argc, char *argv[], char *envp[])
{
char *e, *gfarm_url, *local_path, **new_env, *cwd_env, *pwd_env;
int i, j, status, envc, rank = -1, nodes = -1;
pid_t pid;
static const char env_node_rank[] = "GFARM_NODE_RANK=";
static const char env_node_size[] = "GFARM_NODE_SIZE=";
static const char env_flags[] = "GFARM_FLAGS=";
static const char env_gfs_pwd[] = "GFS_PWD=";
static const char env_pwd[] = "PWD=";
char rankbuf[sizeof(env_node_rank) + GFARM_INT64STRLEN];
char nodesbuf[sizeof(env_node_size) + GFARM_INT64STRLEN];
char flagsbuf[sizeof(env_flags) + 3];
char cwdbuf[PATH_MAX * 2], pwdbuf[PATH_MAX * 2];
e = gfarm_initialize(&argc, &argv);
if (e != NULL) {
errmsg("gfarm_initialize", e);
exit(1);
}
/*
* don't use getopt(3) here, because getopt(3) in glibc refers
* argv[] passed to main(), instead of argv[] passed to getopt(3).
*/
for (i = 1; i < argc; i++) {
if (argv[i][0] != '-')
break;
for (j = 1; argv[i][j] != '\0'; j++) {
switch (argv[i][j]) {
case 'I':
if (argv[i][j + 1] != '\0') {
rank = strtol(&argv[i][j+1], NULL, 0);
j += strlen(&argv[i][j + 1]);
} else if (i + 1 < argc) {
rank = strtol(argv[++i], NULL, 0);
j = strlen(argv[i]) - 1;
} else {
errmsg("-I", "missing argument");
print_usage();
}
break;
case 'N':
if (argv[i][j + 1] != '\0') {
nodes = strtol(&argv[i][j+1], NULL, 0);
j += strlen(&argv[i][j + 1]);
} else if (i + 1 < argc) {
nodes = strtol(argv[++i], NULL, 0);
j = strlen(argv[i]) - 1;
} else {
errmsg("-N", "missing argument");
print_usage();
}
break;
case 's':
rank = 0;
nodes = 1;
break;
case 'h':
case '?':
print_usage();
default:
fprintf(stderr, "%s: invalid option -- %c\n",
progname, argv[i][j]);
print_usage();
}
}
}
argc -= i;
argv += i;
if (argc == 0)
print_usage();
e = gfs_realpath(argv[0], &gfarm_url);
if (e != NULL) {
/* XXX check `e' */
local_path = search_path(argv[0]);
} else {
e = gfarm_url_program_get_local_path(gfarm_url, &local_path);
if (e != NULL) {
errmsg(gfarm_url, e);
exit(1);
}
}
e = modify_ld_library_path();
if (e != NULL) {
errmsg("modify_ld_library_path", e);
/* continue */
}
/*
* the followings are only needed for pid==0 case.
* but isn't it better to check errors before fork(2)?
*
* If gfs_pio_get_node_{rank,size}() fails, continue to
* execute as a single process (not parallel processes).
*/
if (rank == -1) {
e = gfs_pio_get_node_rank(&rank);
if (e != NULL)
rank = 0;
}
if (nodes == -1) {
e = gfs_pio_get_node_size(&nodes);
if (e != NULL)
nodes = 1;
}
for (envc = 0; envp[envc] != NULL; envc++)
;
new_env = malloc(sizeof(*new_env) * (envc + 5 + 1));
memcpy(cwdbuf, GFARM_URL_PREFIX, GFARM_URL_PREFIX_LENGTH);
e = gfs_getcwd(cwdbuf + GFARM_URL_PREFIX_LENGTH,
sizeof(cwdbuf) - GFARM_URL_PREFIX_LENGTH);
if (e != NULL) {
errmsg("cannot get current directory", e);
exit(1);
}
if ((cwd_env = malloc(strlen(cwdbuf) + sizeof(env_gfs_pwd))) == NULL) {
fprintf(stderr, "%s: no memory for %s%s\n",
progname, env_gfs_pwd, cwdbuf);
exit(1);
}
(void)chdir(cwdbuf); /* rely on syscall hook. it is ok if it fails */
getcwd(pwdbuf, sizeof pwdbuf);
pwd_env = malloc(strlen(pwdbuf) + sizeof(env_pwd));
if (pwd_env == NULL) {
fprintf(stderr, "%s: no memory for %s%s\n",
progname, env_pwd, pwdbuf);
exit(1);
}
envc = 0;
for (i = 0; (e = envp[i]) != NULL; i++) {
if (memcmp(e, env_node_rank, sizeof(env_node_rank) -1 ) != 0 &&
memcmp(e, env_node_size, sizeof(env_node_size) -1 ) != 0 &&
memcmp(e, env_flags, sizeof(env_flags) - 1 ) != 0 &&
memcmp(e, env_gfs_pwd, sizeof(env_gfs_pwd) - 1) != 0 &&
memcmp(e, env_pwd, sizeof(env_pwd) - 1 ) != 0)
new_env[envc++] = e;
}
sprintf(rankbuf, "%s%d", env_node_rank, rank);
new_env[envc++] = rankbuf;
sprintf(nodesbuf, "%s%d", env_node_size, nodes);
new_env[envc++] = nodesbuf;
sprintf(flagsbuf, "%s%s%s%s", env_flags,
gf_profile ? "p" : "",
gf_on_demand_replication ? "r" : "",
gf_hook_default_global ? "g" : "");
new_env[envc++] = flagsbuf;
sprintf(cwd_env, "%s%s", env_gfs_pwd, cwdbuf);
new_env[envc++] = cwd_env;
sprintf(pwd_env, "%s%s", env_pwd, pwdbuf);
new_env[envc++] = pwd_env;
new_env[envc++] = NULL;
if (gf_stdout == NULL && gf_stderr == NULL) {
/* what we need is to call exec(2) */
pid = 0;
} else {
/*
* we have to call fork(2) and exec(2), to close
* gf_stdout and gf_stderr by calling gfarm_terminate()
* after the child program finished.
*/
pid = fork();
}
switch (pid) {
case -1:
perror(PROGRAM_NAME ": fork");
status = 255;
break;
case 0:
if (gf_stdout == NULL && gf_stderr == NULL) {
/*
* not to display profile statistics
* on gfarm_terminate()
*/
gfs_profile(gf_profile = 0);
e = gfarm_terminate();
if (e != NULL)
errmsg("(child) gfarm_terminate", e);
} else {
/*
* otherwise don't call gfarm_terminate(), because:
* - it closes gf_stdout and gf_stderr.
* - it causes:
* "gfarm_terminate: Can't contact LDAP server"
* on the parent process.
*/
}
execve(local_path, argv, new_env);
if (errno != ENOEXEC) {
perror(local_path);
} else {
/*
* argv[-1] must be available,
* because there should be "gfexec" at least.
*/
argv[-1] = BOURNE_SHELL;
argv[0] = local_path;
execve(BOURNE_SHELL, argv - 1, new_env);
}
_exit(255);
default:
if (waitpid(pid, &status, 0) == -1) {
perror(PROGRAM_NAME ": waitpid");
status = 255;
} else if (WIFSIGNALED(status)) {
fprintf(stderr, "%s: signal %d received%s.\n",
gfarm_host_get_self_name(), WTERMSIG(status),
WCOREDUMP(status) ? " (core dumped)" : "");
status = 255;
} else {
status = WEXITSTATUS(status);
}
break;
}
/* not to display profile statistics on gfarm_terminate() */
gfs_profile(gf_profile = 0);
e = gfarm_terminate();
if (e != NULL) {
errmsg("gfarm_terminate", e);
exit(1);
}
exit(status);
}
int
main(int argc, char *argv[])
{
/* options */
char *section = NULL;
int nfragments = GFARM_FILE_DONTCARE; /* -1, actually */
char *hostname = NULL;
char *hostfile = NULL;
char *domainname = NULL;
char *e, *gfarm_url, *file_mode_arg;
gfarm_mode_t file_mode = DEFAULT_FILE_MODE;
int c, i, is_dir, index;
struct gfs_stat gs;
e = gfarm_initialize(&argc, &argv);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(EXIT_FAILURE);
}
/* Command options */
while ((c = getopt(argc, argv, "a:fh:D:I:N:?")) != -1) {
switch (c) {
case 'I':
case 'a':
section = optarg;
break;
case 'N':
nfragments = strtol(optarg, NULL, 0);
break;
case 'h':
hostname = optarg;
break;
case 'D':
domainname = optarg;
break;
case 'f':
opt_force = 1;
break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc == 0) {
fprintf(stderr, "%s: missing a local filename\n",
program_name);
usage();
}
if (argc == 1) {
fprintf(stderr, "%s: missing a Gfarm URL\n",
program_name);
usage();
}
gfarm_url = argv[argc - 1];
--argc;
if (!gfarm_is_url(gfarm_url)) {
fprintf(stderr, "%s: %s: %s\n",
program_name, gfarm_url,
GFARM_ERR_GFARM_URL_PREFIX_IS_MISSING);
exit(EXIT_FAILURE);
}
c = 0;
if (hostname != NULL)
c++;
if (hostfile != NULL)
c++;
if (domainname != NULL)
c++;
if (c > 1) {
fprintf(stderr,
"%s: more than one options are specified "
"from -h, -H and -D\n",
program_name);
usage();
}
/*
* distinguish which mode is specified:
* 1. program mode:
* gfreg [-h <hostname>] [-a <architecture>] \
* <local-program>... <gfarm-URL>
* 2. auto index mode:
* gfreg [-h <hostname>] [-H <hostfile>] [-D <domainname>] \
* <local-file>... <gfarm-URL>
* 3. fragment mode:
* gfreg [-h <hostname>] [-N <nfragments>] -I <index> \
* <local-file>... <gfarm-URL>
*/
e = gfs_stat(gfarm_url, &gs);
if (e == GFARM_ERR_NO_SUCH_OBJECT) {
is_dir = 0;
file_mode_arg = NULL;
} else if (e != NULL) {
fprintf(stderr, "%s: %s: %s\n", program_name, gfarm_url, e);
exit(EXIT_FAILURE);
} else {
if (GFARM_S_ISREG(gs.st_mode)) {
is_dir = 0;
file_mode_arg = gfarm_url;
file_mode = gs.st_mode;
} else if (GFARM_S_ISDIR(gs.st_mode)) {
is_dir = 1;
file_mode_arg = NULL;
} else { /* defensive programming. this shouldn't happen. */
fprintf(stderr, "%s: %s: unknown file type\n",
program_name, gfarm_url);
exit(EXIT_FAILURE);
}
gfs_stat_free(&gs);
}
c = 0; /* count of "-" in the arguments */
if (hostfile != NULL && strcmp(hostfile, STDIN_FILENAME) == 0)
++c;
for (i = 0; i < argc; i++) {
int fd, fd_needs_close;
gfarm_mode_t m;
if (!open_file(argv[i], &fd, &fd_needs_close))
exit(EXIT_FAILURE);
if (!get_mode(fd, argv[i], &m))
exit(EXIT_FAILURE);
if (S_ISREG(m)) {
if (file_mode_arg == NULL) {
/*
* NOTE: this mode may be used for the mode
* to create the gfarm file.
*/
file_mode_arg = argv[i];
file_mode = m & FILE_MODE_MASK;
}
if (((m & 0111) != 0) != ((file_mode & 0111) != 0)) {
fprintf(stderr,
"%s: program and non-program are mixed in "
"%s and %s\n",
program_name, file_mode_arg, argv[i]);
exit(EXIT_FAILURE);
}
} else if (fd_needs_close) {
/* if it's "-", allow non-file (e.g. pipe) */
fprintf(stderr, "%s: %s: not a regular file\n",
program_name, argv[i]);
exit(EXIT_FAILURE);
}
if (fd_needs_close) {
close(fd);
} else if (++c > 1) {
fprintf(stderr, "%s: `-' (stdin) is specified "
"multiple times\n", program_name);
exit(EXIT_FAILURE);
}
}
if ((file_mode & 0111) != 0) {
/*
* program mode
*/
int section_alloced = 0;
if (!is_dir && argc != 1) {
fprintf(stderr, "%s: only one file can be specified to"
" register the gfarm program `%s'\n",
program_name, gfarm_url);
exit(EXIT_FAILURE);
}
if (hostfile != NULL || domainname != NULL) {
fprintf(stderr,
"%s: cannot use -%c to register programs\n",
program_name, hostfile != NULL ? 'H' : 'D');
exit(EXIT_FAILURE);
}
if (nfragments != GFARM_FILE_DONTCARE) {
/*
* XXX - call gfarm_url_replicate() to replicate
* `nfragments' copies of gfarm_url:section?
*/
fprintf(stderr,
"%s: warning: option -N is currently ignored\n",
program_name);
}
if (section != NULL) {
;
} else if (hostname != NULL) {
char *canonical;
e = gfarm_host_get_canonical_name(hostname,
&canonical);
if (e != NULL) {
if (e == GFARM_ERR_NO_SUCH_OBJECT)
e = "not a filesystem node";
fprintf(stderr, "%s: host %s: %s\n",
program_name, hostname, e);
exit(EXIT_FAILURE);
}
section_alloced = 1;
section = gfarm_host_info_get_architecture_by_host(
canonical);
free(canonical);
if (section == NULL) {
fprintf(stderr, "%s: %s\n",
program_name, GFARM_ERR_NO_MEMORY);
exit(EXIT_FAILURE);
}
} else if (gfarm_host_get_self_architecture(§ion) != NULL){
fprintf(stderr, "%s: missing -a option\n",
program_name);
exit(EXIT_FAILURE);
}
for (i = 0; i < argc; i++) {
register_program(is_dir, gfarm_url, section,
hostname, argv[i],
file_mode_arg == gfarm_url ||
file_mode_arg == argv[i],
file_mode);
}
if (section_alloced)
free(section);
} else if (section != NULL || gfs_pio_get_node_rank(&index) == NULL) {
/*
* fragment mode
*/
if (section != NULL)
index = strtol(section, NULL, 0);
else if (nfragments == GFARM_FILE_DONTCARE)
gfs_pio_get_node_size(&nfragments);
if (!is_dir && argc != 1) {
fprintf(stderr, "%s: only one file can be specified to"
" register a fragment %s of the gfarm file `%s'\n",
program_name, section, gfarm_url);
exit(EXIT_FAILURE);
}
if (hostfile != NULL || domainname != NULL) {
fprintf(stderr,
"%s: cannot use -%c with -I\n",
program_name, hostfile != NULL ? 'H' : 'D');
exit(EXIT_FAILURE);
}
for (i = 0; i < argc; i++) {
register_fragment(is_dir, gfarm_url, index, nfragments,
hostname, argv[i],
file_mode_arg == gfarm_url ||
file_mode_arg == argv[i],
file_mode);
}
} else {
/*
* auto index mode
*/
char **hosts = NULL;
if (nfragments == GFARM_FILE_DONTCARE)
nfragments = argc;
if (nfragments != argc) {
fprintf(stderr, "%s: local file number %d "
"doesn't match with -N %d\n",
program_name, argc, nfragments);
exit(EXIT_FAILURE);
}
if (is_dir && nfragments > 1) {
fprintf(stderr, "%s: cannot determine the file name "
"under the directory %s, "
"because multiple local file names are specifed\n",
program_name, gfarm_url);
exit(EXIT_FAILURE);
}
if (hostname != NULL) {
;
} else if (hostfile != NULL) {
int nhosts, error_line;
e = gfarm_hostlist_read(hostfile,
&nhosts, &hosts, &error_line);
if (e != NULL) {
if (error_line != -1)
fprintf(stderr, "%s: %s line %d: %s\n",
program_name,
hostfile, error_line, e);
else
fprintf(stderr, "%s: %s: %s\n",
program_name, hostfile, e);
exit(EXIT_FAILURE);
}
} else {
hosts = malloc(sizeof(*hosts) * nfragments);
if (hosts == NULL) {
fprintf(stderr, "%s: %s\n", program_name,
GFARM_ERR_NO_MEMORY);
exit(EXIT_FAILURE);
}
if (domainname != NULL)
e = gfarm_schedule_search_idle_by_domainname(
domainname, nfragments, hosts);
else
e = gfarm_schedule_search_idle_by_all(
nfragments, hosts);
if (e != NULL) {
fprintf(stderr,
"%s: selecting filesystem nodes: %s\n",
program_name, e);
exit(EXIT_FAILURE);
}
}
/* XXX - need to register in parallel? */
for (i = 0; i < argc; i++) {
register_fragment(is_dir, gfarm_url, i, nfragments,
hostname != NULL ? hostname : hosts[i], argv[i],
1, file_mode);
}
if (hostname == NULL)
gfarm_strings_free_deeply(nfragments, hosts);
}
e = gfarm_terminate();
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(EXIT_FAILURE);
}
exit(error_happened);
}
int
main(int argc, char *argv[])
{
extern int optind;
int c, i, error = 0;
gfarm_stringlist paths;
gfs_glob_t types;
char *e;
if (argc <= 1)
usage();
program_name = basename(argv[0]);
while ((c = getopt(argc, argv, "hv?")) != EOF) {
switch (c) {
case 'v':
option_verbose = 1;
break;
case 'h':
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
e = gfarm_initialize(&argc, &argv);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(1);
}
e = gfarm_stringlist_init(&paths);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(EXIT_FAILURE);
}
e = gfs_glob_init(&types);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(EXIT_FAILURE);
}
for (i = 0; i < argc; i++)
gfs_glob(argv[i], &paths, &types);
for (i = 0; i < gfarm_stringlist_length(&paths); i++) {
char *url = gfarm_stringlist_elem(&paths, i);
e = gfsck_dir("", url);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", url, e);
error = 1;
}
}
gfs_glob_free(&types);
gfarm_stringlist_free_deeply(&paths);
e = gfarm_terminate();
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(1);
}
exit(error);
}
int
main(int argc, char **argv)
{
gfarm_error_t e;
int c, use_conn, flags, op = 0;
const char *filename, *filename2 = NULL;
char *path;
struct op_closure closure;
struct gfm_connection *conn;
gfarm_error_t (*inode_request_op)(struct gfm_connection *,
struct gfp_xdr_context *, void *, const char *) = NULL;
gfarm_error_t (*name_request_op)(struct gfm_connection *,
struct gfp_xdr_context *, void *,
const char *, const char *) = NULL;
if (argc > 0)
program_name = basename(argv[0]);
e = gfarm_initialize(&argc, &argv);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "gfarm_initialize: %s\n",
gfarm_error_string(e));
return (EXIT_ERR);
}
while ((c = getopt(argc, argv, "IJNPQRSp")) != -1) {
switch (c) {
case OP_INODE_OP:
case OP_INODE_OP_NF:
case OP_NAME_OP:
case OP_NAME2_OP:
case OP_NAME2_OP_OL:
case OP_REALPATH:
case OP_SHOW_SVR:
if (op != 0) {
fprintf(stderr,
"%s : too many options", program_name);
usage();
}
op = c;
break;
case 'p': /* for OP_NAME_OP */
open_parent = 1;
break;
default:
fprintf(stderr, "%s: unknown option -%c\n",
program_name, c);
usage();
}
}
if (optind == 1)
usage();
argc -= optind;
argv += optind;
switch (op) {
case OP_NAME2_OP:
case OP_NAME2_OP_OL:
use_conn = 1;
if (argc != 2)
usage();
break;
case OP_SHOW_SVR:
if (argc != 0)
usage();
break;
default:
if (argc != 1)
usage();
break;
}
filename = argv[0];
if (argc > 0)
filename2 = argv[1];
memset(&closure, 0, sizeof(closure));
if (use_conn &&
(e = gfm_client_connection_and_process_acquire_by_path(
"/", &conn)) != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s",
program_name, gfarm_error_string(e));
exit(1);
}
switch (op) {
case OP_INODE_OP:
if ((e = gfm_inode_op_modifiable(filename,
GFARM_FILE_RDONLY,
inode_op_request, inode_op_result,
inode_op_success, inode_op_cleanup, NULL, &closure))
!= GFARM_ERR_NO_ERROR) {
fprintf(stderr, "gfm_inode_op : %s\n",
gfarm_error_string(e));
break;
}
assert(closure.request);
assert(closure.result);
assert(closure.success);
assert(closure.cleanup == 0);
printf("%ld\n", (long)closure.f1.ino);
break;
case OP_INODE_OP_NF:
if ((e = gfm_inode_op_no_follow_modifiable(filename,
GFARM_FILE_RDONLY,
inode_op_request, inode_op_result,
inode_op_success, inode_op_cleanup,
NULL, &closure))
!= GFARM_ERR_NO_ERROR) {
fprintf(stderr, "gfm_inode_op_no_follow : %s\n",
gfarm_error_string(e));
break;
}
assert(closure.request);
assert(closure.result);
assert(closure.success);
assert(closure.cleanup == 0);
printf("%ld\n", (long)closure.f1.ino);
break;
case OP_NAME_OP:
if ((e = gfm_name_op_modifiable(filename,
GFARM_ERR_OPERATION_NOT_PERMITTED,
name_op_request, name_op_result,
name_op_success, NULL, &closure))
!= GFARM_ERR_NO_ERROR) {
fprintf(stderr, "gfm_name_op : %s\n",
gfarm_error_string(e));
break;
}
assert(closure.request);
assert(closure.result);
assert(closure.success);
assert(closure.cleanup == 0);
assert(strlen(closure.f1.name) > 0);
assert(closure.f1.ino > 0);
printf("%ld %s\n", (long)closure.f1.ino,
closure.f1.name);
break;
case OP_NAME2_OP:
case OP_NAME2_OP_OL:
if (op == OP_NAME2_OP) {
flags = 0;
name_request_op = name2_op_request;
} else {
flags = GFARM_FILE_SYMLINK_NO_FOLLOW |
GFARM_FILE_OPEN_LAST_COMPONENT;
closure.is_stat_or_open = 1;
inode_request_op = name2_op_ol_request;
}
if ((e = gfm_name2_op_modifiable(filename, filename2, flags,
inode_request_op, name_request_op,
name2_op_result, name2_op_success,
name2_op_cleanup, NULL, &closure))
!= GFARM_ERR_NO_ERROR) {
fprintf(stderr, "gfm_name2_op : %s\n",
gfarm_error_string(e));
break;
}
assert(closure.request);
assert(closure.result);
assert(closure.success);
assert(closure.cleanup == 0);
assert(strlen(closure.f1.name) > 0);
assert(closure.f1.ino > 0);
printf("%ld %s %ld %s\n",
(long)closure.f1.ino, closure.f1.name,
(long)closure.f2.ino, closure.f2.name);
break;
case OP_REALPATH:
if ((e = gfs_realpath(filename, &path))
!= GFARM_ERR_NO_ERROR) {
fprintf(stderr, "gfs_realpath : %s\n",
gfarm_error_string(e));
break;
}
printf("%s\n", path);
free(path);
break;
case OP_SHOW_SVR:
printf("%s:%d\n", gfarm_ctxp->metadb_server_name,
gfarm_ctxp->metadb_server_port);
e = GFARM_ERR_NO_ERROR;
break;
default:
assert(0);
}
if (e != GFARM_ERR_NO_ERROR) {
switch (e) {
case GFARM_ERR_PATH_IS_ROOT:
return (EXIT_PATH_ROOT);
case GFARM_ERR_NO_SUCH_FILE_OR_DIRECTORY:
return (EXIT_NO_SUCH_FILE);
case GFARM_ERR_CROSS_DEVICE_LINK:
return (EXIT_CROSS_DEVICE);
case GFARM_ERR_TOO_MANY_LEVELS_OF_SYMBOLIC_LINK:
return (EXIT_MANY_LVL_OF_SYMLNK);
case GFARM_ERR_OPERATION_NOT_PERMITTED:
return (EXIT_OPE_NOT_PERM);
default:
return (EXIT_ERR);
}
}
if ((e = gfarm_terminate()) != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "gfarm_terminate: %s\n",
gfarm_error_string(e));
return (EXIT_ERR);
}
return (EXIT_OK);
}
int
main(int argc, char **argv)
{
gfarm_error_t e;
int c, i, status = 0;
char *s, *user = NULL, *group = NULL;
extern int optind;
if (argc > 0)
program_name = basename(argv[0]);
if (strcasecmp(program_name, "gfchgrp") == 0)
opt_chgrp = 1;
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, "h?")) != -1) {
switch (c) {
case 'h':
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
if (argc <= 1)
usage();
if (!opt_chgrp) {
if (argv[0][0] == ':') {
group = &argv[0][1];
} else if ((s = strchr(argv[0], ':')) != NULL) {
*s = '\0';
user = argv[0];
group = s + 1;
} else {
user = argv[0];
}
} else {
group = argv[0];
}
for (i = 1; i < argc; i++) {
e = gfs_chown(argv[i], user, group);
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s: %s\n",
program_name, argv[i], gfarm_error_string(e));
status = 1;
}
}
e = gfarm_terminate();
if (e != GFARM_ERR_NO_ERROR) {
fprintf(stderr, "%s: %s\n", program_name,
gfarm_error_string(e));
status = 1;
}
return (status);
}