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)
{
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);
}
