/**
* @brief test case for output arrangement with head and tail meets.
*/
void testcase_output_arrangement_headandtail() {
const MEET_TIME meets[] = {
{1, 5}, {2, 3}, {3, 4}, {3, 6}
};
const int meets_size = sizeof(meets) / sizeof(meets[0]);
MTIME* mtimes = get_mtimes(meets, meets_size);
const int mtimes_size = meets_size*2;
mtime_quicksort(mtimes, 0, mtimes_size-1);
int i = 0, curcolor = 0, maxcolor = 0;
for (i = 0; i < mtimes_size; i ++) {
if (mtimes[i].type == _BEGIN) {
curcolor ++;
if (maxcolor < curcolor) { maxcolor = curcolor; }
} else {
curcolor --;
}
}
printf("max color use in head and tail meets arrangement = %d\n", maxcolor);
free(mtimes);
}
int main (int argc, char** argv)
{
/* initialize MPI */
MPI_Init(&argc, &argv);
mfu_init();
/* get our rank and the size of comm_world */
int rank, ranks;
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
MPI_Comm_size(MPI_COMM_WORLD, &ranks);
/* pointer to mfu_walk_opts */
mfu_walk_opts_t* walk_opts = mfu_walk_opts_new();
/* capture current time for any time based queries,
* to get a consistent value, capture and bcast from rank 0 */
mfu_pred_times* now_t = mfu_pred_now();
int ch;
mfu_pred* pred_head = mfu_pred_new();
char* inputname = NULL;
char* outputname = NULL;
int walk = 0;
int text = 0;
static struct option long_options[] = {
{"input", 1, 0, 'i'},
{"output", 1, 0, 'o'},
{"verbose", 0, 0, 'v'},
{"quiet", 0, 0, 'q'},
{"help", 0, 0, 'h'},
{ "maxdepth", required_argument, NULL, 'd' },
{ "amin", required_argument, NULL, 'a' },
{ "anewer", required_argument, NULL, 'B' },
{ "atime", required_argument, NULL, 'A' },
{ "cmin", required_argument, NULL, 'c' },
{ "cnewer", required_argument, NULL, 'D' },
{ "ctime", required_argument, NULL, 'C' },
{ "mmin", required_argument, NULL, 'm' },
{ "newer", required_argument, NULL, 'N' },
{ "mtime", required_argument, NULL, 'M' },
{ "gid", required_argument, NULL, 'g' },
{ "group", required_argument, NULL, 'G' },
{ "uid", required_argument, NULL, 'u' },
{ "user", required_argument, NULL, 'U' },
{ "name", required_argument, NULL, 'n' },
{ "path", required_argument, NULL, 'P' },
{ "regex", required_argument, NULL, 'r' },
{ "size", required_argument, NULL, 's' },
{ "type", required_argument, NULL, 't' },
{ "print", no_argument, NULL, 'p' },
{ "exec", required_argument, NULL, 'e' },
{ NULL, 0, NULL, 0 },
};
options.maxdepth = INT_MAX;
int usage = 0;
while (1) {
int c = getopt_long(
argc, argv, "i:o:vqh",
long_options, NULL
);
if (c == -1) {
break;
}
int i;
int space;
char* buf;
mfu_pred_times* t;
mfu_pred_times_rel* tr;
regex_t* r;
int ret;
/* verbose by default */
mfu_debug_level = MFU_LOG_VERBOSE;
switch (c) {
case 'e':
space = 1024 * 1024;
buf = (char *)MFU_MALLOC(space);
for (i = optind-1; strcmp(";", argv[i]); i++) {
if (i > argc) {
if (rank == 0) {
printf("%s: exec missing terminating ';'\n", argv[0]);
}
exit(1);
}
strncat(buf, argv[i], space);
space -= strlen(argv[i]) + 1; /* save room for space or null */
if (space <= 0) {
if (rank == 0) {
printf("%s: exec argument list too long.\n", argv[0]);
}
mfu_free(&buf);
continue;
}
strcat(buf, " ");
optind++;
}
buf[strlen(buf)] = '\0'; /* clobbers trailing space */
mfu_pred_add(pred_head, MFU_PRED_EXEC, buf);
break;
case 'd':
options.maxdepth = atoi(optarg);
break;
case 'g':
/* TODO: error check argument */
buf = MFU_STRDUP(optarg);
mfu_pred_add(pred_head, MFU_PRED_GID, (void *)buf);
break;
case 'G':
buf = MFU_STRDUP(optarg);
mfu_pred_add(pred_head, MFU_PRED_GROUP, (void *)buf);
break;
case 'u':
/* TODO: error check argument */
buf = MFU_STRDUP(optarg);
mfu_pred_add(pred_head, MFU_PRED_UID, (void *)buf);
break;
case 'U':
buf = MFU_STRDUP(optarg);
mfu_pred_add(pred_head, MFU_PRED_USER, (void *)buf);
break;
case 's':
buf = MFU_STRDUP(optarg);
mfu_pred_add(pred_head, MFU_PRED_SIZE, (void *)buf);
break;
case 'n':
mfu_pred_add(pred_head, MFU_PRED_NAME, MFU_STRDUP(optarg));
break;
case 'P':
mfu_pred_add(pred_head, MFU_PRED_PATH, MFU_STRDUP(optarg));
break;
case 'r':
r = (regex_t*) MFU_MALLOC(sizeof(regex_t));
ret = regcomp(r, optarg, 0);
if (ret) {
MFU_ABORT(-1, "Could not compile regex: `%s' rc=%d\n", optarg, ret);
}
mfu_pred_add(pred_head, MFU_PRED_REGEX, (void*)r);
break;
case 'a':
tr = mfu_pred_relative(optarg, now_t);
mfu_pred_add(pred_head, MFU_PRED_AMIN, (void *)tr);
break;
case 'm':
tr = mfu_pred_relative(optarg, now_t);
mfu_pred_add(pred_head, MFU_PRED_MMIN, (void *)tr);
break;
case 'c':
tr = mfu_pred_relative(optarg, now_t);
mfu_pred_add(pred_head, MFU_PRED_CMIN, (void *)tr);
break;
case 'A':
tr = mfu_pred_relative(optarg, now_t);
mfu_pred_add(pred_head, MFU_PRED_ATIME, (void *)tr);
break;
case 'M':
tr = mfu_pred_relative(optarg, now_t);
mfu_pred_add(pred_head, MFU_PRED_MTIME, (void *)tr);
break;
case 'C':
tr = mfu_pred_relative(optarg, now_t);
mfu_pred_add(pred_head, MFU_PRED_CTIME, (void *)tr);
break;
case 'B':
t = get_mtimes(optarg);
if (t == NULL) {
if (rank == 0) {
printf("%s: can't find file %s\n", argv[0], optarg);
}
exit(1);
}
mfu_pred_add(pred_head, MFU_PRED_ANEWER, (void *)t);
break;
case 'N':
t = get_mtimes(optarg);
if (t == NULL) {
if (rank == 0) {
printf("%s: can't find file %s\n", argv[0], optarg);
}
exit(1);
}
mfu_pred_add(pred_head, MFU_PRED_MNEWER, (void *)t);
break;
case 'D':
t = get_mtimes(optarg);
if (t == NULL) {
if (rank == 0) {
printf("%s: can't find file %s\n", argv[0], optarg);
}
exit(1);
}
mfu_pred_add(pred_head, MFU_PRED_CNEWER, (void *)t);
break;
case 'p':
mfu_pred_add(pred_head, MFU_PRED_PRINT, NULL);
break;
case 't':
ret = add_type(pred_head, *optarg);
if (ret != 1) {
if (rank == 0) {
printf("%s: unsupported file type %s\n", argv[0], optarg);
}
exit(1);
}
break;
case 'i':
inputname = MFU_STRDUP(optarg);
break;
case 'o':
outputname = MFU_STRDUP(optarg);
break;
case 'v':
mfu_debug_level = MFU_LOG_VERBOSE;
break;
case 'q':
mfu_debug_level = MFU_LOG_NONE;
break;
case 'h':
usage = 1;
break;
case '?':
usage = 1;
break;
default:
if (rank == 0) {
printf("?? getopt returned character code 0%o ??\n", c);
}
}
}
pred_commit(pred_head);
/* paths to walk come after the options */
int numpaths = 0;
mfu_param_path* paths = NULL;
if (optind < argc) {
/* got a path to walk */
walk = 1;
/* determine number of paths specified by user */
numpaths = argc - optind;
/* allocate space for each path */
paths = (mfu_param_path*) MFU_MALLOC((size_t)numpaths * sizeof(mfu_param_path));
/* process each path */
char** p = &argv[optind];
mfu_param_path_set_all((uint64_t)numpaths, (const char**)p, paths);
optind += numpaths;
/* don't allow user to specify input file with walk */
if (inputname != NULL) {
usage = 1;
}
}
else {
/* if we're not walking, we must be reading,
* and for that we need a file */
if (inputname == NULL) {
usage = 1;
}
}
if (usage) {
if (rank == 0) {
print_usage();
}
mfu_finalize();
MPI_Finalize();
return 0;
}
/* create an empty file list */
mfu_flist flist = mfu_flist_new();
if (walk) {
/* walk list of input paths */
mfu_flist_walk_param_paths(numpaths, paths, walk_opts, flist);
}
else {
/* read data from cache file */
mfu_flist_read_cache(inputname, flist);
}
/* apply predicates to each item in list */
mfu_flist flist2 = mfu_flist_filter_pred(flist, pred_head);
/* write data to cache file */
if (outputname != NULL) {
if (!text) {
mfu_flist_write_cache(outputname, flist2);
} else {
mfu_flist_write_text(outputname, flist2);
}
}
/* free off the filtered list */
mfu_flist_free(&flist2);
/* free users, groups, and files objects */
mfu_flist_free(&flist);
/* free predicate list */
mfu_pred_free(&pred_head);
/* free memory allocated for options */
mfu_free(&outputname);
mfu_free(&inputname);
/* free the path parameters */
mfu_param_path_free_all(numpaths, paths);
/* free memory allocated to hold params */
mfu_free(&paths);
/* free structure holding current time */
mfu_free(&now_t);
/* free the walk options */
mfu_walk_opts_delete(&walk_opts);
/* shut down MPI */
mfu_finalize();
MPI_Finalize();
return 0;
}
