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)
{
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)
{
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[])
{
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);
}
static char *
replicate_so_and_symlink(char *dir, size_t size)
{
char *canonic_path, *gfarm_url, *so_pat, *lpath;
char *e, *e_save;
int i, rv;
gfarm_stringlist paths;
gfs_glob_t types;
static char so_pat_template[] = "/*.so*";
e = gfs_mntpath_canonicalize(dir, size, &canonic_path);
if (e != NULL)
return (e);
e = gfarm_path_canonical_to_url(canonic_path, &gfarm_url);
free(canonic_path);
if (e != NULL)
return (e);
so_pat = malloc(strlen(gfarm_url) + sizeof(so_pat_template));
if (so_pat == NULL) {
free(gfarm_url);
return (GFARM_ERR_NO_MEMORY);
}
sprintf(so_pat, "%s%s", gfarm_url, so_pat_template);
free(gfarm_url);
e_save = gfarm_stringlist_init(&paths);
if (e_save != NULL)
goto free_so_pat;
e_save = gfs_glob_init(&types);
if (e_save != NULL)
goto free_paths;
e_save = gfs_glob(so_pat, &paths, &types);
if (e_save != NULL)
goto free_types;
/* XXX - should replicate so files in parallel */
for (i = 0; i < gfarm_stringlist_length(&paths); i++) {
char *gfarm_so, *local_so;
gfarm_so = gfarm_stringlist_elem(&paths, i);
if (strcmp(gfarm_so, so_pat) == 0) /* no "*.so*" file in dir */
break;
e = gfarm_url_execfile_replicate_to_local(gfarm_so, &lpath);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", gfarm_so, e);
if (e_save == NULL)
e_save = e;
if (e == GFARM_ERR_NO_MEMORY)
break;
continue;
}
/* create a symlink */
e = gfarm_url_localize(gfarm_so, &local_so);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", gfarm_so, e);
if (e_save == NULL)
e_save = e;
if (e == GFARM_ERR_NO_MEMORY)
break;
free(lpath);
continue;
}
unlink(local_so);
rv = symlink(lpath, local_so);
if (rv == -1) {
perror(local_so);
if (e_save == NULL)
e_save = gfarm_errno_to_error(errno);
}
free(local_so);
free(lpath);
}
free_types:
gfs_glob_free(&types);
free_paths:
gfarm_stringlist_free_deeply(&paths);
free_so_pat:
free(so_pat);
return (e_save);
}
int
main(int argc, char **argv)
{
char *e;
gfarm_stringlist paths;
gfs_glob_t types;
int i, c, exit_code = EXIT_SUCCESS;
extern char *optarg;
if (argc > 0)
program_name = basename(argv[0]);
e = gfarm_initialize(&argc, &argv);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
exit(EXIT_FAILURE);
}
if (isatty(STDOUT_FILENO)) {
char *s = getenv("COLUMNS");
#ifdef TIOCGWINSZ
struct winsize win;
#endif
if (s != NULL)
screen_width = strtol(s, NULL, 0);
#ifdef TIOCGWINSZ
else if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &win) == 0 &&
win.ws_col > 0)
screen_width = win.ws_col;
#endif
option_output_format = OF_MULTI_COLUMN;
} else {
option_output_format = OF_ONE_PER_LINE;
}
while ((c = getopt(argc, argv, "1CFRSTdlrt?")) != -1) {
switch (c) {
case '1': option_output_format = OF_ONE_PER_LINE; break;
case 'C': option_output_format = OF_MULTI_COLUMN; break;
case 'F': option_type_suffix = 1; break;
case 'R': option_recursive = 1; break;
case 'S': option_sort_order = SO_SIZE; break;
case 'T': option_complete_time = 1; break;
case 'd': option_directory_itself = 1; break;
case 'l': option_output_format = OF_LONG; break;
case 'r': option_reverse_sort = 1; break;
case 't': option_sort_order = SO_MTIME; break;
case '?':
default:
usage();
}
}
argc -= optind;
argv += optind;
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);
}
if (argc < 1) {
gfarm_stringlist_add(&paths, "gfarm:.");
gfs_glob_add(&types, GFS_DT_DIR);
} else {
for (i = 0; i < argc; i++) {
int last;
/* do not treat glob error as an error */
gfs_glob(argv[i], &paths, &types);
last = gfs_glob_length(&types) - 1;
if (last >= 0 && gfs_glob_elem(&types, last) ==
GFS_DT_UNKNOWN) {
/*
* Currently, this only happens if there is
* no file which matches with argv[i].
* In such case, the number of entries which
* were added by gfs_glob() is 1.
* But also please note that GFS_DT_UNKNOWN
* may happen on other case in future.
*/
struct gfs_stat s;
char *path = gfarm_stringlist_elem(&paths,
last);
e = gfs_stat(path, &s);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", path, e);
exit_code = EXIT_FAILURE;
/* remove last entry */
/* XXX: FIXME layering violation */
free(paths.array[last]);
paths.length--;
types.length--;
} else {
GFS_GLOB_ELEM(types, last) =
GFARM_S_ISDIR(s.st_mode) ?
GFS_DT_DIR : GFS_DT_REG;
gfs_stat_free(&s);
}
}
}
}
if (gfarm_stringlist_length(&paths) > 0) {
int need_newline = 0;
#if 1
if (list(&paths, &types, &need_newline) != NULL) {
/* warning is already printed in list() */
exit_code = EXIT_FAILURE;
}
#else
for (i = 0; i < gfarm_stringlist_length(&paths); i++)
printf("<%s>\n", gfarm_stringlist_elem(&paths, i));
#endif
}
return (exit_code);
}
char *
list_dir(char *prefix, char *dirname, int *need_newline)
{
char *e, *s, *path, *e_save = NULL;
gfarm_stringlist names;
gfs_glob_t types;
GFS_Dir dir;
struct gfs_dirent *entry;
int len = strlen(prefix) + strlen(dirname);
path = malloc(len + 1 + 1);
if (path == NULL)
return (GFARM_ERR_NO_MEMORY);
sprintf(path, "%s%s", prefix, dirname);
e = gfarm_stringlist_init(&names);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
free(path);
return (e);
}
e = gfs_glob_init(&types);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", program_name, e);
gfarm_stringlist_free(&names);
free(path);
return (e);
}
e = gfs_opendir(path, &dir);
if (e != NULL) {
fprintf(stderr, "%s: %s\n", path, e);
gfs_glob_free(&types);
gfarm_stringlist_free(&names);
free(path);
return (e);
}
while ((e = gfs_readdir(dir, &entry)) == NULL && entry != NULL) {
s = strdup(entry->d_name);
if (s == NULL) {
e = GFARM_ERR_NO_MEMORY;
break;
}
gfarm_stringlist_add(&names, s);
gfs_glob_add(&types, entry->d_type);
}
if (e != NULL) {
fprintf(stderr, "%s%s: %s\n", prefix, dirname, e);
e_save = e;
}
gfs_closedir(dir);
if (*gfarm_path_dir_skip(gfarm_url_prefix_skip(path)) != '\0') {
path[len] = '/';
path[len + 1] = '\0';
}
e = list_files(path, gfarm_stringlist_length(&names),
GFARM_STRINGLIST_STRARRAY(names), need_newline);
if (e_save == NULL)
e_save = e;
if (option_recursive) {
int i;
for (i = 0; i < gfarm_stringlist_length(&names); i++) {
s = GFARM_STRINGLIST_STRARRAY(names)[i];
if (s[0] == '.' && (s[1] == '\0' ||
(s[1] == '.' && s[2] == '\0')))
continue;
if (gfs_glob_elem(&types, i) == GFS_DT_DIR) {
e = list_dirs(path, 1, &s, need_newline);
if (e_save == NULL)
e_save = e;
}
}
}
gfs_glob_free(&types);
gfarm_stringlist_free_deeply(&names);
free(path);
return (e_save);
}