Mercurialrazor / file revision
summary | shortlog | changelog | graph | tags | branches | files | changeset | file | revisions | annotate | diff | raw
main.c
author Kristian H?gsberg <krh@redhat.com>
Sun Apr 06 19:34:58 2008 -0400 (2008-04-06)
changeset 191 6e94ebe58141
parent 188 a272b6ce454b
child 192 55b177b689c0
permissions -rw-r--r--
Merger structs razor_transaction and razor_transaction_resolver.

Now that both are opaque and hidden in razor.c we can do this cleanup. 
     1 #include <stdlib.h>

     2 #include <stddef.h>

     3 #include <stdio.h>

     4 #include <stdint.h>

     5 #include <string.h>

     6 #include <sys/stat.h>

     7 #include <unistd.h>

     8 #include <dirent.h>

     9 #include <curl/curl.h>

    10 #include <fnmatch.h>

    11 #include "razor.h"

    12 #include "razor-internal.h"

    13 

    14 static const char system_repo_filename[] = "system.repo";

    15 static const char next_repo_filename[] = "system-next.repo";

    16 static const char rawhide_repo_filename[] = "rawhide.repo";

    17 static const char updated_repo_filename[] = "system-updated.repo";

    18 static const char razor_root_path[] = "/var/lib/razor";

    19 static const char root[] = "install";

    20 static const char *repo_filename = system_repo_filename;

    21 

    22 static int

    23 command_list(int argc, const char *argv[])

    24 {

    25 	struct razor_set *set;

    26 	struct razor_package_iterator *pi;

    27 	struct razor_package *package;

    28 	const char *pattern, *name, *version;

    29 	int only_names = 0, i = 0;

    30 

    31 	if (strcmp(argv[i], "--only-names") == 0) {

    32 		only_names = 1;

    33 		i++;

    34 	}

    35 

    36 	pattern = argv[i];

    37 	set = razor_set_open(repo_filename);

    38 	pi = razor_package_iterator_create(set);

    39 	while (razor_package_iterator_next(pi, &package, &name, &version)) {

    40 		if (pattern && fnmatch(pattern, name, 0) != 0)

    41 			continue;

    42 

    43 		if (only_names)

    44 			printf("%s\n", name);

    45 		else

    46 			printf("%s-%s\n", name, version);

    47 	}

    48 	razor_package_iterator_destroy(pi);

    49 	razor_set_destroy(set);

    50 

    51 	return 0;

    52 }

    53 

    54 static int

    55 list_properties(const char *package_name,

    56 		enum razor_property_type required_type)

    57 {

    58 	struct razor_set *set;

    59 	struct razor_property *property;

    60 	struct razor_package *package;

    61 	struct razor_property_iterator *pi;

    62 	const char *name, *version;

    63 	enum razor_property_type type;

    64 	enum razor_version_relation relation;

    65 

    66 	set = razor_set_open(repo_filename);

    67 	if (package_name)

    68 		package = razor_set_get_package(set, package_name);

    69 	else

    70 		package = NULL;

    71 

    72 	pi = razor_property_iterator_create(set, package);

    73 	while (razor_property_iterator_next(pi, &property,

    74 					    &name, &relation, &version,

    75 					    &type)) {

    76 		if (type != required_type)

    77 			continue;

    78 		if (version[0] == '\0')

    79 			printf("%s\n", name);

    80 		else

    81 			printf("%s %s %s\n", name,

    82 			       razor_version_relations[relation], version);

    83 	}

    84 	razor_property_iterator_destroy(pi);

    85 

    86 	razor_set_destroy(set);

    87 

    88 	return 0;

    89 }

    90 

    91 static int

    92 command_list_requires(int argc, const char *argv[])

    93 {

    94 	return list_properties(argv[0], RAZOR_PROPERTY_REQUIRES);

    95 }

    96 

    97 static int

    98 command_list_provides(int argc, const char *argv[])

    99 {

   100 	return list_properties(argv[0], RAZOR_PROPERTY_PROVIDES);

   101 }

   102 

   103 static int

   104 command_list_obsoletes(int argc, const char *argv[])

   105 {

   106 	return list_properties(argv[0], RAZOR_PROPERTY_OBSOLETES);

   107 }

   108 

   109 static int

   110 command_list_conflicts(int argc, const char *argv[])

   111 {

   112 	return list_properties(argv[0], RAZOR_PROPERTY_CONFLICTS);

   113 }

   114 

   115 static int

   116 command_list_files(int argc, const char *argv[])

   117 {

   118 	struct razor_set *set;

   119 

   120 	set = razor_set_open(repo_filename);

   121 	if (set == NULL)

   122 		return 1;

   123 	razor_set_list_files(set, argv[0]);

   124 	razor_set_destroy(set);

   125 

   126 	return 0;

   127 }

   128 

   129 static int

   130 command_list_file_packages(int argc, const char *argv[])

   131 {

   132 	struct razor_set *set;

   133 	struct razor_package_iterator *pi;

   134 	struct razor_package *package;

   135 	const char *name, *version;

   136 

   137 	set = razor_set_open(repo_filename);

   138 	if (set == NULL)

   139 		return 1;

   140 

   141 	pi = razor_package_iterator_create_for_file(set, argv[0]);

   142 	while (razor_package_iterator_next(pi, &package, &name, &version))

   143 		printf("%s-%s\n", name, version);

   144 	razor_package_iterator_destroy(pi);

   145 

   146 	razor_set_destroy(set);

   147 

   148 	return 0;

   149 }

   150 

   151 static int

   152 command_list_package_files(int argc, const char *argv[])

   153 {

   154 	struct razor_set *set;

   155 

   156 	set = razor_set_open(repo_filename);

   157 	if (set == NULL)

   158 		return 1;

   159 	razor_set_list_package_files(set, argv[0]);

   160 	razor_set_destroy(set);

   161 

   162 	return 0;

   163 }

   164 

   165 static void

   166 list_packages_for_property(struct razor_set *set,

   167 			   struct razor_property *property)

   168 {

   169 	struct razor_package_iterator *pi;

   170 	struct razor_package *package;

   171 	const char *name, *version;

   172 

   173 	pi = razor_package_iterator_create_for_property(set, property);

   174 	while (razor_package_iterator_next(pi, &package, &name, &version))

   175 		printf("%s-%s\n", name, version);

   176 	razor_package_iterator_destroy(pi);

   177 }

   178 

   179 static int

   180 list_property_packages(const char *ref_name,

   181 		       const char *ref_version,

   182 		       enum razor_property_type ref_type)

   183 {

   184 	struct razor_set *set;

   185 	struct razor_property *property;

   186 	struct razor_property_iterator *pi;

   187 	const char *name, *version;

   188 	enum razor_property_type type;

   189 	enum razor_version_relation relation;

   190 

   191 	if (ref_name == NULL)

   192 		return 0;

   193 

   194 	set = razor_set_open(repo_filename);

   195 	if (set == NULL)

   196 		return 1;

   197 

   198 	pi = razor_property_iterator_create(set, NULL);

   199 	while (razor_property_iterator_next(pi, &property,

   200 					    &name, &relation, &version,

   201 					    &type)) {

   202 		if (strcmp(ref_name, name) != 0)

   203 			continue;

   204 		if (ref_version && relation == RAZOR_VERSION_EQUAL &&

   205 		    strcmp(ref_version, version) != 0)

   206 			continue;

   207 		if (ref_type != type)

   208 			continue;

   209 

   210 		list_packages_for_property(set, property);

   211 	}

   212 	razor_property_iterator_destroy(pi);

   213 

   214 	return 0;

   215 }

   216 

   217 static int

   218 command_what_requires(int argc, const char *argv[])

   219 {

   220 	return list_property_packages(argv[0], argv[1],

   221 				      RAZOR_PROPERTY_REQUIRES);

   222 }

   223 

   224 static int

   225 command_what_provides(int argc, const char *argv[])

   226 {

   227 	return list_property_packages(argv[0], argv[1],

   228 				      RAZOR_PROPERTY_PROVIDES);

   229 }

   230 

   231 static int

   232 show_progress(void *clientp,

   233 	      double dltotal, double dlnow, double ultotal, double ulnow)

   234 {

   235 	const char *file = clientp;

   236 

   237 	if (!dlnow < dltotal)

   238 		fprintf(stderr, "\rdownloading %s, %dkB/%dkB",

   239 			file, (int) dlnow / 1024, (int) dltotal / 1024);

   240 

   241 	return 0;

   242 }

   243 

   244 static int

   245 download_if_missing(CURL *curl, const char *url, const char *file)

   246 {

   247 	struct stat buf;

   248 	char error[256];

   249 	FILE *fp;

   250 	CURLcode res;

   251 

   252 	curl_easy_setopt(curl, CURLOPT_ERRORBUFFER, error);

   253 	curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);

   254 	curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, show_progress);

   255 	curl_easy_setopt(curl, CURLOPT_PROGRESSDATA, file);

   256 

   257 	if (stat(file, &buf) < 0) {

   258 		fp = fopen(file, "w");

   259 		curl_easy_setopt(curl, CURLOPT_WRITEDATA, fp);

   260 		curl_easy_setopt(curl, CURLOPT_URL, url);

   261 		res = curl_easy_perform(curl);

   262 		fclose(fp);

   263 		if (res != CURLE_OK) {

   264 			fprintf(stderr, "curl error: %s\n", error);

   265 			unlink(file);

   266 			return -1;

   267 		}

   268 		fprintf(stderr, "\n");

   269 	}

   270 

   271 	return 0;

   272 }

   273 

   274 #define REPO_URL "http://download.fedora.redhat.com" \

   275 	"/pub/fedora/linux/development/i386/os"

   276 

   277 static int

   278 command_import_yum(int argc, const char *argv[])

   279 {

   280 	struct razor_set *set;

   281 	CURL *curl;

   282 

   283 	curl = curl_easy_init();

   284 	if (curl == NULL)

   285 		return 1;

   286 

   287 	if (download_if_missing(curl,

   288 				REPO_URL "/repodata/primary.xml.gz",

   289 				"primary.xml.gz") < 0)

   290 		return -1;

   291 	if (download_if_missing(curl,

   292 				REPO_URL "/repodata/filelists.xml.gz",

   293 				"filelists.xml.gz") < 0)

   294 		return -1;

   295 	curl_easy_cleanup(curl);

   296 

   297 	set = razor_set_create_from_yum();

   298 	if (set == NULL)

   299 		return 1;

   300 	razor_set_write(set, rawhide_repo_filename);

   301 	razor_set_destroy(set);

   302 	printf("wrote %s\n", rawhide_repo_filename);

   303 

   304 	return 0;

   305 }

   306 

   307 static int

   308 command_import_rpmdb(int argc, const char *argv[])

   309 {

   310 	struct razor_set *set;

   311 

   312 	set = razor_set_create_from_rpmdb();

   313 	if (set == NULL)

   314 		return 1;

   315 	razor_set_write(set, repo_filename);

   316 	razor_set_destroy(set);

   317 	printf("wrote %s\n", repo_filename);

   318 

   319 	return 0;

   320 }

   321 

   322 static int

   323 command_validate(int argc, const char *argv[])

   324 {

   325 	struct razor_set *set;

   326 

   327 	set = razor_set_open(repo_filename);

   328 	if (set == NULL)

   329 		return 1;

   330 	razor_set_list_unsatisfied(set);

   331 	razor_set_destroy(set);

   332 

   333 	return 0;

   334 }

   335 

   336 static int

   337 command_update(int argc, const char *argv[])

   338 {

   339 	struct razor_set *set, *upstream;

   340 	struct razor_transaction *trans;

   341 	int errors;

   342 

   343 	set = razor_set_open(repo_filename);

   344 	upstream = razor_set_open(rawhide_repo_filename);

   345 	if (set == NULL || upstream == NULL)

   346 		return 1;

   347 	trans = razor_transaction_create(set, upstream, argc, argv, 0, NULL);

   348 	errors = razor_transaction_describe(trans);

   349 	if (errors)

   350 		return 1;

   351 

   352 	set = razor_transaction_run(trans);

   353 	razor_transaction_destroy(trans);

   354 	razor_set_write(set, updated_repo_filename);

   355 	razor_set_destroy(set);

   356 	razor_set_destroy(upstream);

   357 	printf("wrote system-updated.repo\n");

   358 

   359 	return 0;

   360 }

   361 

   362 static int

   363 command_remove(int argc, const char *argv[])

   364 {

   365 	struct razor_set *set;

   366 	struct razor_transaction *trans;

   367 	int errors;

   368 

   369 	set = razor_set_open(repo_filename);

   370 	if (set == NULL)

   371 		return 1;

   372 	trans = razor_transaction_create(set, NULL, 0, NULL, argc, argv);

   373 	errors = razor_transaction_describe(trans);

   374 	if (errors)

   375 		return 1;

   376 

   377 	set = razor_transaction_run(trans);

   378 	razor_transaction_destroy(trans);

   379 	razor_set_write(set, updated_repo_filename);

   380 	razor_set_destroy(set);

   381 	printf("wrote system-updated.repo\n");

   382 

   383 	return 0;

   384 }

   385 

   386 static void

   387 print_diff(const char *name,

   388 	   const char *old_version, const char *new_version, void *data)

   389 {

   390 	if (old_version)

   391 		printf("removing %s %s\n", name, old_version);

   392 	else

   393 		printf("install %s %s\n", name, new_version);

   394 }

   395 

   396 static int

   397 command_diff(int argc, const char *argv[])

   398 {

   399 	struct razor_set *set, *updated;

   400 

   401 	set = razor_set_open(repo_filename);

   402 	updated = razor_set_open(updated_repo_filename);

   403 	if (set == NULL || updated == NULL)

   404 		return 1;

   405 

   406 	razor_set_diff(set, updated, print_diff, NULL);	

   407 

   408 	razor_set_destroy(set);

   409 	razor_set_destroy(updated);

   410 

   411 	return 0;

   412 }

   413 

   414 static int

   415 command_import_rpms(int argc, const char *argv[])

   416 {

   417 	DIR *dir;

   418 	struct dirent *de;

   419 	struct razor_importer *importer;

   420 	struct razor_set *set;

   421 	struct razor_rpm *rpm;

   422 	int len;

   423 	char filename[256];

   424 	const char *dirname = argv[0];

   425 

   426 	if (dirname == NULL) {

   427 		fprintf(stderr, "usage: razor import-rpms DIR\n");

   428 		return -1;

   429 	}

   430 

   431 	dir = opendir(dirname);

   432 	if (dir == NULL) {

   433 		fprintf(stderr, "couldn't read dir %s\n", dirname);

   434 		return -1;

   435 	}

   436 

   437 	importer = razor_importer_new();

   438 

   439 	while (de = readdir(dir), de != NULL) {

   440 		len = strlen(de->d_name);

   441 		if (len < 5 || strcmp(de->d_name + len - 4, ".rpm") != 0)

   442 		    continue;

   443 		snprintf(filename, sizeof filename,

   444 			 "%s/%s", dirname, de->d_name);

   445 		rpm = razor_rpm_open(filename);

   446 		if (rpm == NULL) {

   447 			fprintf(stderr,

   448 				"failed to open rpm \"%s\"\n", filename);

   449 			continue;

   450 		}

   451 		if (razor_importer_add_rpm(importer, rpm)) {

   452 			fprintf(stderr, "couldn't import %s\n", filename);

   453 			break;

   454 		}

   455 		razor_rpm_close(rpm);

   456 	}

   457 

   458 	if (de != NULL) {

   459 		razor_importer_destroy(importer);

   460 		return -1;

   461 	}

   462 

   463 	set = razor_importer_finish(importer);

   464 

   465 	razor_set_write(set, repo_filename);

   466 	razor_set_destroy(set);

   467 	printf("wrote %s\n", repo_filename);

   468 

   469 	return 0;

   470 }

   471 

   472 static struct razor_set *

   473 create_set_from_rpms(int argc, const char *argv[])

   474 {

   475 	struct razor_importer *importer;

   476 	struct razor_rpm *rpm;

   477 	int i;

   478 

   479 	importer = razor_importer_new();

   480 	for (i = 0; i < argc; i++) {

   481 		rpm = razor_rpm_open(argv[i]);

   482 		if (rpm == NULL) {

   483 			fprintf(stderr,

   484 				"failed to open rpm \"%s\"\n", argv[i]);

   485 			continue;

   486 		}

   487 		if (razor_importer_add_rpm(importer, rpm)) {

   488 			fprintf(stderr, "couldn't import %s\n", argv[i]);

   489 			break;

   490 		}

   491 		razor_rpm_close(rpm);

   492 	}

   493 

   494 	return razor_importer_finish(importer);

   495 }

   496 

   497 static char **

   498 list_packages(int count, struct razor_set *set)

   499 {

   500 	struct razor_package_iterator *pi;

   501 	struct razor_package *package;

   502 	const char *name, *version;

   503 	char **packages;

   504 	int i;

   505 

   506 	packages = malloc(count * sizeof *packages);

   507 	pi = razor_package_iterator_create(set);

   508 	i = 0;

   509 	while (razor_package_iterator_next(pi, &package, &name, &version))

   510 		packages[i++] = strdup(name);

   511 	razor_package_iterator_destroy(pi);

   512 

   513 	return packages;

   514 }

   515 

   516 static int

   517 command_install(int argc, const char *argv[])

   518 {

   519 	struct razor_set *system, *upstream, *next;

   520 	struct razor_transaction *trans;

   521 	struct razor_rpm *rpm;

   522 	const char *filename;

   523 	char path[PATH_MAX], new_path[PATH_MAX], **packages;

   524 	int errors, i;

   525 

   526 	upstream = create_set_from_rpms(argc, argv);

   527 	snprintf(path, sizeof path,

   528 		 "%s%s/%s", root, razor_root_path, system_repo_filename);

   529 	system = razor_set_open(path);

   530 	if (system == NULL) {

   531 		fprintf(stderr, "couldn't open system package database\n");

   532 		return -1;

   533 	}

   534 

   535 	packages = list_packages(argc, upstream);

   536 	trans = razor_transaction_create(system, upstream,

   537 					 argc, (const char **)packages,

   538 					 0, NULL);

   539 	free(packages);

   540 	errors = razor_transaction_describe(trans);

   541 	if (errors)

   542 		return 1;

   543 

   544 	/* FIXME: Use _finish() convention here?  That is, a function

   545 	 * that starts the computation and returns the result while

   546 	 * destroying the transaction.  Nice for transient objects

   547 	 * such as the merger and the importer.  Should we do that for

   548 	 * transactions too, that is, razor_transaction_finish()? */

   549 	next = razor_transaction_run(trans);

   550 	razor_transaction_destroy(trans);

   551 

   552 	/* FIXME: Need razor_set_write_to_fd() so we can open it excl

   553 	 * up front here or fail if it already exists. */

   554 	snprintf(new_path, sizeof new_path,

   555 		 "%s%s/%s", root, razor_root_path, next_repo_filename);

   556 	razor_set_write(next, path);

   557 

   558 	razor_set_destroy(next);

   559 	razor_set_destroy(system);

   560 	razor_set_destroy(upstream);

   561 

   562 	printf("wrote %s\n", new_path);

   563 

   564 	for (i = 0; i < argc; i++) {

   565 		filename = argv[i];

   566 		rpm = razor_rpm_open(argv[i]);

   567 		if (rpm == NULL) {

   568 			fprintf(stderr, "failed to open rpm %s\n", filename);

   569 			return -1;

   570 		}

   571 		if (razor_rpm_install(rpm, root) < 0) {

   572 			fprintf(stderr,

   573 				"failed to install rpm %s\n", filename);

   574 			return -1;

   575 		}

   576 		razor_rpm_close(rpm);

   577 	}	

   578 

   579 	/* Make it so. */

   580 	rename(new_path, path);

   581 	printf("renamed %s to %s\n", new_path, path);

   582 

   583 	return 0;

   584 }

   585 

   586 static int

   587 command_init(int argc, const char *argv[])

   588 {

   589 	struct stat buf;

   590 	struct razor_set *set;

   591 	char path[PATH_MAX];

   592 

   593 	if (stat(root, &buf) < 0) {

   594 		if (mkdir(root, 0777) < 0) {

   595 			fprintf(stderr,

   596 				"could not create install root \"%s\"\n",

   597 				root);

   598 			return -1;

   599 		}

   600 		fprintf(stderr, "created install root \"%s\"\n", root);

   601 	} else if (!S_ISDIR(buf.st_mode)) {

   602 		fprintf(stderr,

   603 			"install root \"%s\" exists, but is not a directory\n",

   604 			root);

   605 		return -1;

   606 	}

   607 

   608 	if (razor_create_dir(root, razor_root_path) < 0) {

   609 		fprintf(stderr, "could not create %s%s\n",

   610 			root, razor_root_path);

   611 		return -1;

   612 	}

   613 

   614 	set = razor_set_create();

   615 	snprintf(path, sizeof path, "%s%s/%s",

   616 		 root, razor_root_path, system_repo_filename);

   617 	if (razor_set_write(set, path) < 0) {

   618 		fprintf(stderr, "could not write initial package set\n");

   619 		return -1;

   620 	}

   621 	razor_set_destroy(set);

   622 

   623 	return 0;

   624 }

   625 

   626 static int

   627 command_download(int argc, const char *argv[])

   628 {

   629 	struct razor_set *set;

   630 	struct razor_package_iterator *pi;

   631 	struct razor_package *package;

   632 	const char *pattern = argv[0], *name, *version;

   633 	char url[256], file[256];

   634 	CURL *curl;

   635 

   636 	curl = curl_easy_init();

   637 	if (curl == NULL)

   638 		return 1;

   639 

   640 	set = razor_set_open(rawhide_repo_filename);

   641 	pi = razor_package_iterator_create(set);

   642 	while (razor_package_iterator_next(pi, &package, &name, &version)) {

   643 		if (pattern && fnmatch(pattern, name, 0) != 0)

   644 			continue;

   645 

   646 		snprintf(url, sizeof url,

   647 			 REPO_URL "/Packages/%s-%s.i386.rpm", name, version);

   648 		snprintf(file, sizeof file,

   649 			 "rpms/%s-%s.i386.rpm", name, version);

   650 		if (download_if_missing(curl, url, file) < 0)

   651 			fprintf(stderr, "failed to download %s\n", name);

   652 	}

   653 	razor_package_iterator_destroy(pi);

   654 	razor_set_destroy(set);

   655 	curl_easy_cleanup(curl);

   656 

   657 	return 0;

   658 }

   659 

   660 static struct {

   661 	const char *name;

   662 	const char *description;

   663 	int (*func)(int argc, const char *argv[]);

   664 } razor_commands[] = {

   665 	{ "list", "list all packages", command_list },

   666 	{ "list-requires", "list all requires for the given package", command_list_requires },

   667 	{ "list-provides", "list all provides for the given package", command_list_provides },

   668 	{ "list-obsoletes", "list all obsoletes for the given package", command_list_obsoletes },

   669 	{ "list-conflicts", "list all conflicts for the given package", command_list_conflicts },

   670 	{ "list-files", "list files for package set", command_list_files },

   671 	{ "list-file-packages", "list packages owning file", command_list_file_packages },

   672 	{ "list-package-files", "list files in package", command_list_package_files },

   673 	{ "what-requires", "list the packages that have the given requires", command_what_requires },

   674 	{ "what-provides", "list the packages that have the given provides", command_what_provides },

   675 	{ "import-yum", "import yum metadata files", command_import_yum },

   676 	{ "import-rpmdb", "import the system rpm database", command_import_rpmdb },

   677 	{ "import-rpms", "import rpms from the given directory", command_import_rpms },

   678 	{ "validate", "validate a package set", command_validate },

   679 	{ "update", "update all or specified packages", command_update },

   680 	{ "remove", "remove specified packages", command_remove },

   681 	{ "diff", "show diff between two package sets", command_diff },

   682 	{ "install", "install rpm", command_install },

   683 	{ "init", "init razor root", command_init },

   684 	{ "download", "download packages", command_download }

   685 };

   686 

   687 static int

   688 usage(void)

   689 {

   690 	int i;

   691 

   692 	printf("usage:\n");

   693 	for (i = 0; i < ARRAY_SIZE(razor_commands); i++)

   694 		printf("  %-20s%s\n",

   695 		       razor_commands[i].name, razor_commands[i].description);

   696 

   697 	return 1;

   698 }

   699 

   700 int

   701 main(int argc, const char *argv[])

   702 {

   703 	char *repo;

   704 	int i;

   705 

   706 	repo = getenv("RAZOR_REPO");

   707 	if (repo != NULL)

   708 		repo_filename = repo;

   709 

   710 	if (argc < 2)

   711 		return usage();

   712 

   713 	for (i = 0; i < ARRAY_SIZE(razor_commands); i++)

   714 		if (strcmp(razor_commands[i].name, argv[1]) == 0)

   715 			return razor_commands[i].func(argc - 2, argv + 2);

   716 

   717 	return usage();

   718 }
razor