def main(): parser = create_parser( description="Export products from a muninn archive.", parallel=True) parser.add_argument( "-d", "--directory", type=directory, help="directory in which retrieved products will be" " stored; by default, retrieved products will be stored in the current working directory" ) parser.add_argument( "-f", "--format", type=export_format, help="format in which to export the products; if left" " unspecified, the default export format for the product type will be used" ) parser.add_argument("-l", "--list-formats", action="store_true", help="list alternative (non-default) export" " formats supported by the archive and exit") parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") parser.add_argument( "expression", metavar="EXPRESSION", help="expression used to search for products to export") return parse_args_and_run(parser, export)
def main(): parser = create_parser(description="Attach product to existing metadata entry in a muninn archive.", parallel=True) group = parser.add_mutually_exclusive_group() group.add_argument("-s", "--path-is-stem", action="store_true", help="each product path is interpreted as a " "stem; any file or directory of which the name starts with this stem is considered to be part " "of the product") group.add_argument("-d", "--path-is-enclosing-directory", action="store_true", help="each product path is " "interpreted as an enclosing directory; the actual product consists of any file or directory " "found inside this enclosing directory; the enclosing directory itself is not considered part " "of the product") parser.add_argument("-e", "--exclude", metavar="PATTERN", action="append", help="exclude any files or " "directories whose basename matches PATTERN; *, ?, and [] can be used as wildcards; to match " "a wildcard character literally, include it within brackets, e.g. [?] to match the character ? " "literally") parser.add_argument("-t", "--product-type", help="force the product type of products to attach") group = parser.add_mutually_exclusive_group() group.add_argument("-l", "--link", action="store_true", help="attach symbolic links to each product") group.add_argument("-k", "--keep", action="store_true", help="attach product, using the current product path if it " "is in the muninn path, otherwise throws an error") parser.add_argument("-f", "--force", action="store_true", help="skip matching size check before attaching products") parser.add_argument("--verify-hash", action="store_true", help="verify the hash of the product after it has been put in the archive") parser.add_argument("--verify-hash-before", action="store_true", help="verify the hash of the product before it is put in the archive") parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") parser.add_argument("path", metavar="PATH", nargs="+", action=CheckProductListAction, help="products to attach, or \"-\" to read the list of products from standard input") return parse_args_and_run(parser, attach)
def main(): parser = create_parser(description="Pull remote files into the archive.", parallel=True) parser.add_argument("--verify-hash", action="store_true", help="verify the hash of the product after it has been put in the archive") parser.add_argument("--verify-hash-download", action="store_true", help="verify the hash of the pulled product before it has been put in the archive") parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") parser.add_argument("expression", metavar="EXPRESSION", help="expression to filter products to pull") return parse_args_and_run(parser, pull)
def main(): parser = create_parser( description="List tags of products contained in a muninn archive") parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") parser.add_argument( "expression", metavar="EXPRESSION", help="expression used to search for products to list tags of") return parse_args_and_run(parser, list_tags)
def main(): parser = create_parser( description= "Set one or more tags on products contained in a muninn archive", parallel=True) parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") parser.add_argument("expression", metavar="EXPRESSION", help="expression used to search for products to tag") parser.add_argument("tag", metavar="TAG", nargs="+", help="tags to set") return parse_args_and_run(parser, tag)
def main(): parser = create_parser(description="Muninn product hashing utilities") sub_parsers = parser.add_subparsers(dest='command', help='sub-command help') sub_parsers.required = True # calc calc = sub_parsers.add_parser('calc', help='calculate hash for local products') calc.add_argument( "path", metavar="PATH", nargs="+", action=CheckProductListAction, help= "list of paths, or \"-\" to read the list of paths from standard input" ) calc.add_argument("--hash-type", default='sha1', help="hash algorithm to use (default sha1)") calc.add_argument( "-s", "--path-is-stem", action="store_true", help="each product path is interpreted as a " "stem; any file or directory of which the name starts with this stem is considered to be part " "of the product") # verify verify = sub_parsers.add_parser('verify', help='verify hash for given products') verify.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") verify.add_argument("expression", metavar="EXPRESSION", default="", help="expression to select products") verify.add_argument("--parallel", action="store_true", help="use multi-processing to perform operation") verify.add_argument( "--processes", type=int, help="use a specific amount of processes for --parallel") return parse_args_and_run(parser, command)
def main(): parser = create_parser( description="Remove a muninn archive and its contents") parser.add_argument( "-c", "--catalogue-only", action="store_true", help="only remove the catalogue database, " "without touching (or removing anything from) the archive root path on disk" ) parser.add_argument("-y", "--yes", action="store_true", help="assume yes and do not prompt for confirmation") parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") return parse_args_and_run(parser, destroy)
def main(): parser = create_parser( description= "Remove one or more tags from products contained in a muninn archive", parallel=True) parser.add_argument( "-a", "--all", action="store_true", help="ignore tags supplied on the command line; instead remove all tags" ) parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") parser.add_argument("expression", metavar="EXPRESSION", help="expression used to search for products to untag") parser.add_argument("tag", metavar="TAG", nargs="*", help="tags to remove") return parse_args_and_run(parser, untag)
def main(): parser = create_parser( description="Strip products contained in a muninn archive (i.e. remove " "products from disk, but don't remove the corresponding entries from the product " "catalogue)", parallel=True) parser.add_argument( "-f", "--force", action="store_true", help="also strip partially ingested products; note" " that this can cause product files to be removed while in the process of being ingested" ) parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") parser.add_argument( "expression", metavar="EXPRESSION", help="expression used to search for products to remove") return parse_args_and_run(parser, strip)
def main(): parser = create_parser(description="Search a muninn archive for products.") parser.add_argument("-f", "--output-format", choices=SUPPORTED_FORMATS, default=default_format, help="output format") parser.add_argument("-l", "--limit", type=int, help="limit the maximum number of products") parser.add_argument("-o", "--order-by", action="append", type=order_by_list, default=[], help="white space " "separated list of sort order specifiers; a \"+\" prefix denotes ascending order; no prefix " "denotes descending order") parser.add_argument("-p", "--property", action="append", type=property_list, dest="properties", help="white space separated list of properties to output; use `<namespace>.*` to include all " "properties of a namespace, e.g. core.*; use `*` to include all namespaces") group = parser.add_mutually_exclusive_group() group.add_argument("-c", "--count", action="store_true", help="suppress normal output; instead print the " "number of products matching the search expression") group.add_argument("-u", "--uuid", action="store_true", help="suppress normal output; instead print the uuid " "of each product found") group.add_argument("--paths", action="store_true", help="suppress normal output; instead print the physical " "path of each product found") parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") parser.add_argument("expression", metavar="EXPRESSION", help="expression used to search for products") return parse_args_and_run(parser, run)
def main(): parser = create_parser( description="Retrieve products from a muninn archive.", parallel=True) parser.add_argument( "-d", "--directory", type=directory, help="directory in which retrieved products will be" " stored; by default, retrieved products will be stored in the current working directory" ) parser.add_argument("-l", "--link", action="store_true", help="retrieve using symbolic links instead of copy") parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") parser.add_argument( "expression", metavar="EXPRESSION", help="expression used to search for products to retrieve") return parse_args_and_run(parser, retrieve)
def main(): parser = create_parser( description="Remove products from a muninn archive.", parallel=True) parser.add_argument("-c", "--catalogue-only", action="store_true", help="remove the entry from the catalogue " "without removing any product from the storage") parser.add_argument( "-f", "--force", action="store_true", help="also remove partially ingested products; note " "that this can cause products to be removed while in the process of being ingested" ) parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") parser.add_argument( "expression", metavar="EXPRESSION", help="expression used to search for products to remove") return parse_args_and_run(parser, remove)
def main(): parser = create_parser( description="Prepare a muninn archive for first use.") parser.add_argument( "-c", "--catalogue-only", action="store_true", help="only prepare the catalogue database, " "without creating (or removing anything from) the archive storage") parser.add_argument( "-f", "--force", action="store_true", help= "force preparation of an existing archive, completely removing all content" ) parser.add_argument("--dry-run", action="store_true", help="dump the SQL statements without executing them") parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") return parse_args_and_run(parser, prepare)
def main(): parser = create_parser( description="Summary of the products matching the search expression.", formatter_class=argparse.RawDescriptionHelpFormatter) parser.add_argument( "-f", "--output-format", choices=OUTPUT_FORMATS, default=DEFAULT_FORMAT, metavar="FORMAT", help="output format; choices (depending on installation of " "python-tabulate): {%(choices)s}; default: %(default)s") parser.add_argument( "-o", "--order-by", action="append", dest="order_by", help="white space " "separated list of sort order specifiers; a \"+\" prefix denotes ascending order; no prefix " "denotes descending order") parser.add_argument( "-g", "--group-by", action="append", dest="group_by", help= "list of property names whose values are used for grouping the aggregation results; " "there will be a separate result row for each combination of group_by property values; " "properties need to be of type long, integer, boolean, text or timestamp; " "timestamps require a binning subscript which can be 'year', 'month', 'yearmonth', 'day', " "'date', 'hour', 'minute', 'second' or 'time' (e.g. `validity_start.yearmonth`)" ) parser.add_argument( "-t", "--group-by-tag", action="store_true", help="group result by tag value; " "note that products will be counted multiple times if they have multiple tags" ) parser.add_argument( "-s", "--stats", action="append", dest="stats", help="list of property aggregates defined as " "`<property_name>.<reduce_fn>`; " "properties need to be of type long, integer, real, text or timestamp; " "the reduce function can be 'min', 'max', 'sum', or 'avg'; " "'sum' and 'avg' are not possible for text and timestamp properties; " "a special property 'validity_duration' (defined as validity_stop - validity_start) can also " "be used; default stats: %r" % ' '.join(DEFAULT_STATS)) parser.add_argument("--stats-filter", metavar='EXPRESSION', help="expression used to filter on aggregates") parser.add_argument("-H", "--human-readable", action="store_true", help="output human readable core.size") parser.add_argument("archive", metavar="ARCHIVE", help="identifier of the archive to use") parser.add_argument("expression", metavar="EXPRESSION", nargs='?', help="expression used to search for products") return parse_args_and_run(parser, run)