neulab/tldr huggingface dataset:
-z undo_file Before overwriting a file system block, write the old contents of the block to an undo file.  This undo file can be used with e2undo(8) to restore the old contents of the file system should something go wrong.  If the empty string is passed as the undo_file argument, the undo file will be written to a file named e2undo-device.e2undo in the directory specified via the E2FSPROGS_UNDO_DIR environment variable.
WARNING: The undo file cannot be used to recover from a power or system crash.
e2undo was written by Aneesh Kumar K.V. (aneesh.kumar@linux.vnet.ibm.com)
e2undo is part of the e2fsprogs package and is available from http://e2fsprogs.sourceforge.net.
STAT(1)                           User Commands                          STAT(1)
stat - display file or file system status
stat [OPTION]... FILE...
Display file or file system status.
-L, --dereference follow links
-f, --file-system display file system status instead of file status
--cached=MODE specify how to use cached attributes; useful on remote file systems. See MODE below
-c  --format=FORMAT use the specified FORMAT instead of the default; output a newline after each use of FORMAT
--printf=FORMAT like --format, but interpret backslash escapes, and do not output a mandatory trailing newline; if you want a newline, include \n in FORMAT
-t, --terse print the information in terse form
The MODE argument of --cached can be: always, never, or default. 'always' will use cached attributes if available, while 'never' will try to synchronize with the latest attributes, and 'default' will leave it up to the underlying file system.
The valid format sequences for files (without --file-system):
%a     permission bits in octal (note '#' and '0' printf flags)
%A     permission bits and file type in human readable form
%b     number of blocks allocated (see %B)
%B     the size in bytes of each block reported by %b
%C     SELinux security context string
%d     device number in decimal (st_dev)
%D     device number in hex (st_dev)
%Hd    major device number in decimal
%Ld    minor device number in decimal
%f     raw mode in hex
%F     file type
%g     group ID of owner
%G     group name of owner
%h     number of hard links
%i     inode number
%m     mount point
%n     file name
%N     quoted file name with dereference if symbolic link
%o     optimal I/O transfer size hint
%s     total size, in bytes
%r     device type in decimal (st_rdev)
%R     device type in hex (st_rdev)
%Hr    major device type in decimal, for character/block device special files
%Lr    minor device type in decimal, for character/block device special files
%t     major device type in hex, for character/block device special files
%T     minor device type in hex, for character/block device special files
%u     user ID of owner
%U     user name of owner
%w     time of file birth, human-readable; - if unknown
%W     time of file birth, seconds since Epoch; 0 if unknown
%x     time of last access, human-readable
%X     time of last access, seconds since Epoch
%y     time of last data modification, human-readable
%Y     time of last data modification, seconds since Epoch
%z     time of last status change, human-readable
%Z     time of last status change, seconds since Epoch
Valid format sequences for file systems:
%a     free blocks available to non-superuser
%b     total data blocks in file system
%c     total file nodes in file system
%d     free file nodes in file system
%f     free blocks in file system
%i     file system ID in hex
%l     maximum length of filenames
%s     block size (for faster transfers)
%S     fundamental block size (for block counts)
%t     file system type in hex
%T     file system type in human readable form
--terse is equivalent to the following FORMAT: %n %s %b %f %u %g %D %i %h %t %T %X %Y %Z %W %o
--terse --file-system is equivalent to the following FORMAT: %n %i %l %t %s %S %b %f %a %c %d
NOTE: your shell may have its own version of stat, which usually supersedes the version described here.  Please refer to your shell's documentation for details about the options it supports.
Written by Michael Meskes.
stat(2), statfs(2), statx(2)
Full documentation <https://www.gnu.org/software/coreutils/stat> or available locally via: info '(coreutils) stat invocation'
CARGO(1)                     General Commands Manual                    CARGO(1)
cargo - The Rust package manager
cargo [options] command [args] cargo [options] --version cargo [options] --list cargo [options] --help cargo [options] --explain code
This program is a package manager and build tool for the Rust language, available at <https://rust-lang.org>.
Build Commands cargo-bench(1) Execute benchmarks of a package.
cargo-build(1) Compile a package.
cargo-check(1) Check a local package and all of its dependencies for errors.
cargo-clean(1) Remove artifacts that Cargo has generated in the past.
cargo-doc(1) Build a package's documentation.
cargo-fetch(1) Fetch dependencies of a package from the network.
cargo-fix(1) Automatically fix lint warnings reported by rustc.
cargo-run(1) Run a binary or example of the local package.
cargo-rustc(1) Compile a package, and pass extra options to the compiler.
cargo-rustdoc(1) Build a package's documentation, using specified custom flags.
cargo-test(1) Execute unit and integration tests of a package.
Manifest Commands cargo-generate-lockfile(1) Generate Cargo.lock for a project.
cargo-locate-project(1) Print a JSON representation of a Cargo.toml file's location.
cargo-metadata(1) Output the resolved dependencies of a package in machine-readable format.
cargo-pkgid(1) Print a fully qualified package specification.
cargo-tree(1) Display a tree visualization of a dependency graph.
cargo-update(1) Update dependencies as recorded in the local lock file.
cargo-vendor(1) Vendor all dependencies locally.
cargo-verify-project(1) Check correctness of crate manifest.
Package Commands cargo-init(1) Create a new Cargo package in an existing directory.
cargo-install(1) Build and install a Rust binary.
cargo-new(1) Create a new Cargo package.
cargo-search(1) Search packages in crates.io.
cargo-uninstall(1) Remove a Rust binary.
Publishing Commands cargo-login(1) Save an API token from the registry locally.
cargo-owner(1) Manage the owners of a crate on the registry.
cargo-package(1) Assemble the local package into a distributable tarball.
cargo-publish(1) Upload a package to the registry.
cargo-yank(1) Remove a pushed crate from the index.
General Commands cargo-help(1) Display help information about Cargo.
cargo-version(1) Show version information.
Special Options -V, --version Print version info and exit. If used with --verbose, prints extra information.
--list List all installed Cargo subcommands. If used with --verbose, prints extra information.
--explain code Run rustc --explain CODE which will print out a detailed explanation of an error message (for example, E0004).
Display Options -v, --verbose Use verbose output. May be specified twice for "very verbose" output which includes extra output such as dependency warnings and build script output. May also be specified with the term.verbose config value <https://doc.rust-lang.org/cargo/reference/config.html>.
Manifest Options --frozen, --locked Either of these flags requires that the Cargo.lock file is up-to-date. If the lock file is missing, or it needs to be updated, Cargo will exit with an error. The --frozen flag also prevents Cargo from attempting to access the network to determine if it is out-of-date.
~/.cargo/ Default location for Cargo's "home" directory where it stores various files. The location can be changed with the CARGO_HOME environment variable.
$CARGO_HOME/bin/ Binaries installed by cargo-install(1) will be located here. If using rustup <https://rust-lang.github.io/rustup/>, executables distributed with Rust are also located here.
$CARGO_HOME/config.toml The global configuration file. See the reference <https://doc.rust-lang.org/cargo/reference/config.html> for more information about configuration files.
.cargo/config.toml Cargo automatically searches for a file named .cargo/config.toml in the current directory, and all parent directories. These configuration files will be merged with the global configuration file.
$CARGO_HOME/credentials.toml Private authentication information for logging in to a registry.
$CARGO_HOME/registry/ This directory contains cached downloads of the registry index and any downloaded dependencies.
$CARGO_HOME/git/ This directory contains cached downloads of git dependencies.
Please note that the internal structure of the $CARGO_HOME directory is not stable yet and may be subject to change.
1. Build a local package and all of its dependencies:
cargo build
2. Build a package with optimizations:
cargo build --release
3. Run tests for a cross-compiled target:
cargo test --target i686-unknown-linux-gnu
4. Create a new package that builds an executable:
cargo new foobar
5. Create a package in the current directory:
mkdir foo && cd foo cargo init .
6. Learn about a command's options and usage:
cargo help clean
See <https://github.com/rust-lang/cargo/issues> for issues.
rustc(1), rustdoc(1)
kubectl - kubectl controls the Kubernetes cluster manager
kubectl [OPTIONS]
kubectl controls the Kubernetes cluster manager.
Find more information at: https://kubernetes.io/docs/reference/kubectl/overview/
kubectl-alpha(1), kubectl-annotate(1), kubectl-api-resources(1), kubectl-api-versions(1), kubectl-apply(1), kubectl-attach(1), kubectl-auth(1), kubectl-autoscale(1), kubectl-certificate(1), kubectl-cluster-info(1), kubectl-completion(1), kubectl-config(1), kubectl-cordon(1), kubectl-cp(1), kubectl-create(1), kubectl-debug(1), kubectl-delete(1), kubectl-describe(1), kubectl-diff(1), kubectl-drain(1), kubectl-edit(1), kubectl-exec(1), kubectl-explain(1), kubectl-expose(1), kubectl-get(1), kubectl-kustomize(1), kubectl-label(1), kubectl-logs(1), kubectl-options(1), kubectl-patch(1), kubectl-plugin(1), kubectl-port-forward(1), kubectl-proxy(1), kubectl-replace(1), kubectl-rollout(1), kubectl-run(1), kubectl-scale(1), kubectl-set(1), kubectl-taint(1), kubectl-top(1), kubectl-uncordon(1), kubectl-version(1), kubectl-wait(1),
MSCORE(1)                  BSD General Commands Manual                 MSCORE(1)
mscore, musescore — MuseScore 3 sheet music editor
mscore [-deFfhIiLmnOPRstvw] [-a | --use-audio driver] [-b | --bitrate bitrate] [-c | --config-folder pathname] [-D | --monitor-resolution DPI] [-E | --install-extension extension file] [-j | --job file.json] [-M | --midi-operations file] [-o | --export-to file] [-p | --plugin name] [-r | --image-resolution DPI] [-S | --style style] [-T | --trim-image margin] [-x | --gui-scaling factor] [--debug] [--diff] [--dump-midi-in] [--dump-midi-out] [--experimental] [--export-score-parts] [--factory-settings] [--force] [--help] [--layout-debug] [--load-icons] [--long-version] [--new-score] [--no-fallback-font] [--no-midi] [--no-synthesizer] [--no-webview] [--raw-diff] [--revert-settings] [--run-test-script] [--save-online] [--score-media] [--highlight-config] [--score-mp3] [--score-parts] [--score-parts-pdf] [--score-transpose] [--source-update] [--template-mode] [--test-mode] [--version] [file ...]
MuseScore is a Free and Open Source WYSIWYG cross-platform multi-lingual music composition and notation software, released under the GNU General Public Licence (GPLv2).
Running mscore without any extra options launches the full graphical MuseScore program and opens any files specified on the command line.
-a | --use-audio driver Use audio driver: one of jack, alsa, portaudio, pulse
-b | --bitrate bitrate Set MP3 output bitrate in kbit/s
-c | --config-folder pathname Override configuration and settings directory
-D | --monitor-resolution DPI Specify monitor resolution (override autodetection)
-d | --debug Start MuseScore in debug mode
-E | --install-extension extension file Install an extension file; soundfonts are loaded by default unless -e is also specified
-e | --experimental Enable experimental features, such as layers
-F | --factory-settings Revert all settings, shortcuts, workspaces, extensions, translations, etc. to factory defaults; compare with the -R option
-f | --force Ignore score corruption and version mismatch warnings in “converter mode”
-h | --help Display an overview of invocation instructions
-I | --dump-midi-in Display all MIDI input on the console
-i | --load-icons Load icons from the filesystem; useful if you want to edit the MuseScore icons and preview the changes
-j | --job file.json Process a conversion job (see EXAMPLES below)
-L | --layout-debug Start MuseScore in layout debug mode
-M | --midi-operations file Specify MIDI import operations file (see EXAMPLES below)
-m | --no-midi Disable MIDI input
-n | --new-score Start with the New Score wizard regardless whether it's enabled or disabled in the user preferences
-O | --dump-midi-out Display all MIDI output on the console
-o | --export-to file Export the given (or currently opened) file to the specified output file.  The file type depends on the extension of the filename given.  This option switches to “converter mode” and avoids the graphical user interface.
-P | --export-score-parts When converting to PDF with the -o option, append each part's pages to the created PDF file.  If the score has no parts, all default parts will temporarily be generated automatically.
-p | --plugin name Execute the named plugin
-R | --revert-settings Revert user preferences to factory default but retain shortcuts, workspaces, extensions, translations, etc.; compare with -F.
-r | --image-resolution DPI Set image resolution for conversion to PNG files.
Default: 360 DPI (actually, the value of “Resolution” of the PNG option group in the Export tab of the preferences)
-S | --style style Load a style file first; useful for use with the -o option
-s | --no-synthesizer Disable the integrated software synthesiser
-T | --trim-image margin Trim exported PNG and SVG images to remove whitespace surrounding the score.  The specified margin, in pixels, will be retained (use 0 for a tightly cropped image).  When exporting to SVG, this option only works with single-page scores.
-t | --test-mode Set test mode flag for all files
-v | --version Display the name and version of the application without starting the graphical user interface
-w | --no-webview Disable the web view component in the Start Centre
-x | --gui-scaling factor Scale the score display and other GUI elements by the specified factor; intended for use with high-resolution displays
--diff  Print a conditioned diff between the given scores
--long-version Display the full name, version and git revision of the application without starting the graphical user interface
--no-fallback-font Don't use a fallback musical font
--raw-diff Print a raw diff between the given scores
--run-test-script Run script tests listed in the command line arguments
--save-online Upload score(s) to its source URL. There must already be an online score at that URL, and the user must be signed-in to the account it belongs to. The online score will be replaced with the uploaded file, but the title and description of the online score's webpage will not change.
--score-media Export all media (except MP3) for a given score as a single JSON document to stdout
--highlight-config Set highlight to svg, generated from a given score
--score-mp3 Generate an MP3 for the given score and export it as a single JSON document to stdout
--score-parts Generate parts data for the given score and save them to separate mscz files
--score-parts-pdf Generate parts data for the given score and export it as a single JSON document to stdout
--score-transpose Transpose the given score and export the data to a single JSON file, print it to stdout
--source-update Update the source in the given score
--template-mode Save files in template mode (e.g. without page sizes)
MuseScore supports the automatic Qt command line options (see below).
Batch conversion job JSON format The argument to the -j option must be the pathname of a file comprised of a valid JSON document honouring the following specification:
•   The top-level element must be a JSONArray, which may be empty.
•   Each array element must be a JSONObject with the following keys:
in      Value is the name of the input file (score to convert), as JSONString.
plugin  Value is the filename of a plugin (with the .qml extension), which will be read from either the global or per-user plugin path and executed before the conversion output happens, as JSONString.  Optional, but at least one of plugin and out must be given.
out     Value is the conversion output target, as defined below. Optional, but at least one of plugin and out must be given.
•   The conversion output target may be a filename (with extension, which decided the format to convert to), as JSONString.
•   The conversion output target may be a JSONArray of filenames as JSONString, as above, which will cause the score to be written to multiple output files (in multiple output formats) sequentially, without being closed, re-opened and re-processed in between.
•   If the conversion output target is a JSONArray, one or more of its elements may also be, each, a JSONArray of two JSONStrings (called first and second half in the following description).  This will cause part extraction: for each such two-tuple, all extant parts of the score will be saved individually, with filenames being composed by concatenating the first half, the name (title) of the part, and the second half.  The resulting string must be a valid filename (with extension, determining the output format).  If a score has no parts (excerpts) defined, this will be silently ignored without error.
•   Valid file extensions for output are:
flac      Free Lossless Audio Codec (compressed audio)
metajson  various score metadata (JSON)
mid       standard MIDI file
midi      standard MIDI file
mlog      internal file sanity check log (JSON)
mp3       MPEG Layer III (lossy compressed audio)
mpos      measure positions (XML)
mscx      uncompressed MuseScore file
mscz      compressed MuseScore file
musicxml  uncompressed MusicXML file
mxl       compressed MusicXML file
ogg       OGG Vorbis (lossy compressed audio)
pdf       portable document file (print)
png       portable network graphics (image)
Individual files, one per score page, with a hyphen-minus followed by the page number placed before the file extension, will be generated.
spos      segment positions (XML)
svg       scalable vector graphics (image)
wav       RIFF Waveform (uncompressed audio)
xml       uncompressed MusicXML file
See below for an example.
SKIP_LIBJACK Set this (the value does not matter) to skip initialisation of the JACK Audio Connection Kit library, in case it causes trouble.
XDG_CONFIG_HOME User configuration location; defaults to ~/.config if unset.
XDG_DATA_HOME User data location; defaults to ~/.local/share if unset.
XDG_DOCUMENTS_DIR Location of works the user created with the application; defaults to ~/Documents (or a localised version) and can be set in $XDG_CONFIG_HOME/user-dirs.dirs.
Note that MuseScore also supports the normal Qt environment variables such as QT_QPA_GENERIC_PLUGINS, QT_QPA_PLATFORM, QT_QPA_PLATFORMTHEME, QT_QPA_PLATFORM_PLUGIN_PATH, QT_STYLE_OVERRIDE, DISPLAY, etc.
/usr/share/mscore-3.6/ contains the application support data (demos, instruments, localisation, system-wide plugins, soundfonts, styles, chords, templates and wallpapers).  In the Debian packages, system-wide soundfonts are installed into /usr/share/sounds/sf2/, /usr/share/sounds/sf3/ or /usr/share/sounds/sfz/, respectively, instead.
The per-user data (extensions, plugins, soundfonts, styles, templates) and files (images, scores) are normally installed into subdirectories under $XDG_DOCUMENTS_DIR/MuseScore3/ but may be changed in the configuration. Note that snapshot, alpha and beta versions use MuseScore3Development instead of MuseScore3 in all of these paths.
$XDG_CONFIG_HOME/MuseScore/MuseScore3.ini contains the user preferences, list of recently used files and their locations, window sizes and positions, etc.  See above for development version paths.
$XDG_DATA_HOME/MuseScore/MuseScore3/ contains updated localisation files downloaded from within the program, plugin information, cached scores, credentials for the musescore.com community site, session information, synthesiser settings, custom key and time signatures and shortcuts.  See above for development version paths.
Convert a score to PDF from the command line:
mscore -o 'My Score.pdf' 'My Score.mscz'
Run a batch job converting multiple documents:
mscore -j job.json
This requires the file job.json in the current working directory to have content similar to the following:
[ { "in": "Reunion.mscz", "out": "Reunion-coloured.pdf", "plugin": "colornotes.qml" }, { "in": "Reunion.mscz", "out": [ "Reunion.pdf", [ "Reunion (part for ", ").pdf" ], "Reunion.musicxml", "Reunion.mid" ] }, { "in": "Piece with excerpts.mscz", "out": [ "Piece with excerpts (Partitura).pdf", [ "Piece with excerpts (part for ", ").pdf" ], "Piece with excerpts.mid" ] } ]
The last part of the job would, for example, cause files like “Piece with excerpts (part for Violin).pdf” to be generated alongside the conductor's partitura and a MIDI file with the full orchestra sound, whereas the equivalent part of the Reunion conversion will be silently ignored (because the Reunion piece (a MuseScore demo) has no excerpts defined).
https://musescore.org/sites/musescore.org/files/midi_import_options_0.xml is a sample MIDI import operations file for the -M option.
The mscore utility exits 0 on success, and >0 if an error occurs.
fluidsynth(1), midicsv(1), timidity(1), qtoptions(7)
https://musescore.org/handbook Online Handbook, full user manual
https://musescore.org/forum Support Forum
https://musescore.org/handbook/command-line-options-0 Further documentation of command line options
https://musescore.org/handbook/revert-factory-settings-0 Reverting to factory settings (troubleshooting)
https://musescore.org/project/issues Project Issue Tracker
Please check first to if the bug you're encountering has already been reported.  If you just need help with something, then please use the support forum (see above) instead.
http://doc.qt.io/qt-5/qguiapplication.html#supported-command-line-options Documentation of automatic Qt command line options
MuseScore attempts to implement the following standards:
•   MusicXML 3.1 (score interchange format)
•   SF2 (SoundFont 2.01)
•   SF3 (SoundFont with OGG Vorbis-compressed samples)
•   SFZ (Sforzato soundfont)
•   SMuFL (Standard Music Font Layout 1.30)
MuseScore was split off the MusE sequencer in 2002 and has since become the foremost Open Source notation software.
MuseScore is developed by MuseScore BVBA and others.
This manual page was written by mirabilos <tg@debian.org>.
The automatic Qt command line options are removed from the argument vector before the application has a chance at option processing; this means that an invocation like
mscore -S -reverse
has no chance at working because the -reverse is removed by Qt first.
MuseScore does not honour /etc/papersize.
Probably some more; check the project's bug tracker (cf. SEE ALSO).
docker-system - Manage Docker
docker system
Manage Docker
-h, --help[=false]      help for system
docker(1), docker-system-df(1), docker-system-events(1), docker-system- info(1), docker-system-prune(1)
MONS(1)                           User Commands                          MONS(1)
Mons - POSIX Shell script to quickly manage 2-monitors display.
mons [OPTION]...
Without argument, it prints connected monitors list with their names and ids.  Options are exclusive and can be used in conjunction with extra options.
Information: -h     Prints this help and exits.
-v     Prints version and exits.
Two monitors: -o     Primary monitor only.
-s     Second monitor only.
-d     Duplicates the primary monitor.
-m     Mirrors the primary monitor.
-e <side>
Extends the primary monitor to the selected side [ top | left | right | bottom ].
-n <side>
This mode selects the previous ones, one after another. The argument sets the side for the extend mode.
More monitors: -O <mon>
Only enables the monitor with a specified id.
-S <mon1>,<mon2>:<pos>
Only enables two monitors with specified ids. The specified position places the second monitor on the right (R) or at the top (T).
Extra (in-conjunction or alone): --dpi <dpi>
Set the DPI, a strictly positive value within the range [0 ; 27432].
--primary <mon_name>
Select a connected monitor as the primary output. Run the script without argument to print monitors information, the names are in the second column between ids and status. The primary monitor is marked by an asterisk.
Daemon mode: -a     Performs an automatic display if it detects only one monitor.
Copyright Â© 2017 Thomas "Ventto" Venries.
License MIT: <https://opensource.org/licenses/MIT>.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
TRASH-PUT(1)                 General Commands Manual                TRASH-PUT(1)
trash-put - Command line trash utility.
trash [OPTION] ...  [ARGUMENTS] ... trash-put [OPTION] ...  [ARGUMENTS] ...
Trash-cli package provides a command line interface trashcan utility compliant with the FreeDesktop.org Trash Specification.  It remembers the name, original path, deletion date, and permissions of each trashed file.
Names of files or directories to move in the trashcan.
-f Silently ignore any files or directories that do not exist.  Do not print error messages, and do not return a nonzero status to the caller, because of any such nonexistent arguments.
-h, --help Show help message and exit.
--trash-dir=TRASHDIR Use TRASHDIR as trash folder.
-v, --verbose Explain what is being done.
$ trash-put foo   # trashes foo
Please, report bugs to https://github.com/andreafrancia/trash-cli/issues
Tweet (to @andreafrancia or #trash-cli) or donate 1, 2 or 5 euros using paypal: https://www.paypal.com/cgi-bin/webscr?cmd=_s- xclick&hosted_button_id=93L6PYT4WBN5A
Trash was written by Andrea Francia <andrea@andreafrancia.it>.  The original version of trash-empty was contributed by Einar Orn Olason <eoo@hi.is>.  The first version of manual pages was written by Steve Stalcup <vorian@ubuntu.com> and was modified by Massimo Cavalleri <submax@tiscalinet.it>.
trash-list(1), trash-restore(1), trash-empty(1), trash-rm(1), and the FreeDesktop.org Trash Specification at http://www.ramendik.ru/docs/trashspec.html.
Both are released under the GNU General Public License, version 2 or later.
kubeadm - kubeadm: easily bootstrap a secure Kubernetes cluster
kubeadm [OPTIONS]
┌──────────────────────────────────────────────────────────┐ │ KUBEADM                                                  │ │ Easily bootstrap a secure Kubernetes cluster             │ │                                                          │ │ Please give us feedback at:                              │ │ https://github.com/kubernetes/kubeadm/issues             │ └──────────────────────────────────────────────────────────┘
Example usage:
Create a two-machine cluster with one control-plane node (which controls the cluster), and one worker node (where your workloads, like Pods and Deployments run).
┌──────────────────────────────────────────────────────────┐ │ On the first machine:                                    │ ├──────────────────────────────────────────────────────────┤ │ control-plane# kubeadm init                              │ └──────────────────────────────────────────────────────────┘
┌──────────────────────────────────────────────────────────┐ │ On the second machine:                                   │ ├──────────────────────────────────────────────────────────┤ │ worker# kubeadm join <arguments-returned-from-init>      │ └──────────────────────────────────────────────────────────┘
You can then repeat the second step on as many other machines as you like.
--rootfs=""      [EXPERIMENTAL] The path to the 'real' host root filesystem.
kubeadm-alpha(1), kubeadm-certs(1), kubeadm-completion(1), kubeadm-config(1), kubeadm-init(1), kubeadm-join(1), kubeadm-kubeconfig(1), kubeadm-reset(1), kubeadm-token(1), kubeadm-upgrade(1), kubeadm-version(1),
jmap(1)                      General Commands Manual                     jmap(1)
Name jmap - Memory Map
jmap [ option ] pid jmap [ option ] executable core jmap [ option ] [server-id@]remote-hostname-or-IP
option Options are mutually exclusive. Option, if used, should follow immediately after the command name.
pid process id for which the memory map is to be printed. The process must be a Java process. To get a list of Java processes running on a machine, jps(1) may be used.
executable Java executable from which the core dump was produced.
core core file for which the memory map is to be printed.
remote-hostname-or-IP remote debug server's (see jsadebugd(1)) hostname or IP address.
server-id optional unique id, if multiple debug servers are running on the same remote host.
jmap prints shared object memory maps or heap memory details of a given process or core file or a remote debug server. If the given process is running on a 64-bit VM, you may need to specify the -J-d64 option, e.g.:
jmap -J-d64 -heap pid
NOTE: This utility is unsupported and may or may not be available in future versions of the JDK. In Windows Systems where dbgeng.dll is not present, 'Debugging Tools For Windows' needs to be installed to have these tools working. Also, PATH environment variable should contain the location of jvm.dll used by the target process or the location from which the Crash Dump file was produced.
For example, set PATH=<jdk>\jre\bin\client;%PATH%
<no option> When no option is used jmap prints shared object mappings. For each shared object loaded in the target VM, start address, the size of the mapping, and the full path of the shared object file are printed. This is similar to the Solaris pmap utility.
-dump:[live,]format=b,file=<filename> Dumps the Java heap in hprof binary format to filename. The live suboption is optional. If specified, only the live objects in the heap are dumped. To browse the heap dump, you can use jhat(1) (Java Heap Analysis Tool) to read the generated file.
-finalizerinfo Prints information on objects awaiting finalization.
-heap Prints a heap summary. GC algorithm used, heap configuration and generation wise heap usage are printed.
-histo[:live] Prints a histogram of the heap. For each Java class, number of objects, memory size in bytes, and fully qualified class names are printed. VM internal class names are printed with '*' prefix. If the live suboption is specified, only live objects are counted.
-permstat Prints class loader wise statistics of permanent generation of Java heap. For each class loader, its name, liveness, address, parent class loader, and the number and size of classes it has loaded are printed. In addition, the number and size of interned Strings are printed.
-F Force. Use with jmap -dump or jmap -histo option if the pid does not respond. The live suboption is not supported in this mode.
-h Prints a help message.
-help Prints a help message.
-J<flag> Passes <flag> to the Java virtual machine on which jmap is run.
o pmap(1)
o jhat(1)
o jps(1)
o jsadebugd(1)
hashid(7)                        hashid man page                       hashid(7)
hashid - Identify the different types of hashes used to encrypt data
hashid [-h] [-e] [-m] [-j] [-o FILE] [--version] INPUT
hashID is a tool written in Python 3.x which supports the identification of over 210 unique hash types using regular expressions.
It is able to identify a single hash, parse a file or read files in a directory and identify the hashes within them.  hashID is also capable of including the corresponding hashcat mode and/or JohnTheRipper format in its output.  Although hashID is written in Python 3.x it should also work with Python 2.7.
-e, --extended list all possible hash algorithms including salted passwords
-m, --mode include corresponding hashcat mode in output
-j, --john include corresponding JohnTheRipper format in output
-o FILE, --outfile FILE write output to file (default: STDOUT)
-h, --help show help message and exit
If you find a bug, please report it at https://github.com/psypanda/hashID/issues
c0re (c0re@psypanda.org)
GIT-RENAME-TAG(1)                  Git Extras                  GIT-RENAME-TAG(1)
git-rename-tag - Rename a tag
git-rename-tag <old-tag-name> <new-tag-name>
Rename a tag (locally and remotely)
<old-tag-name>
The name of the tag you want to rename.
<new-tag-name>
The new name of the tag.
$ git tag test $ git push --tags Total 0 (delta 0), reused 0 (delta 0) To git@myserver.com:myuser/myrepository.git * [new tag]         test -> test $ git tag test $ git rename-tag test test2 Deleted tag ´test´ (was 1111111) Total 0 (delta 0), reused 0 (delta 0) To git@myserver.com:myuser/myrepository.git * [new tag]         test2 -> test2 remote: warning: Deleting a non-existent ref. To git@myserver.com:myuser/myrepository.git - [deleted]         refs/tag/test $ git tag test2
Written by Jesus Espino <jespinog@gmail.com>
Mono(mono)                                                            Mono(mono)
mono - Mono's ECMA-CLI native code generator (Just-in-Time and Ahead-of- Time)
mono [options] file [arguments...]
mono-sgen [options] file [arguments...]
mono is a runtime implementation of the ECMA Common Language Infrastructure.  This can be used to run ECMA and .NET applications.
The runtime loads the specified file and optionally passes the arguments to it.  The file is an ECMA assembly.  They typically have a .exe or .dll extension.
These executables can reference additional functionality in the form of assembly references.  By default those assembly references are resolved as follows: the mscorlib.dll is resolved from the system profile that is configured by Mono, and other assemblies are loaded from the Global Assembly Cache (GAC).
The runtime contains a native code generator that transforms the Common Intermediate Language into native code.
The code generator can operate in two modes: Just-in-time compilation (JIT) or Ahead-of-time compilation (AOT).  Since code can be dynamically loaded, the runtime environment and the JIT are always present, even if code is compiled ahead of time.
The runtime provides a number of configuration options for running applications, for developing and debugging, and for testing and debugging the runtime itself.
The mono command uses the moving and generational SGen garbage collector while the mono-boehm command uses the conservative Boehm garbage collector.
On Unix-based systems, Mono provides a mechanism to emulate the Windows- style file access, this includes providing a case insensitive view of the file system, directory separator mapping (from \ to /) and stripping the drive letters.
This functionality is enabled by setting the MONO_IOMAP environment variable to one of all, drive and case.
See the description for MONO_IOMAP in the environment variables section for more details.
A number of diagnostic command line options take as argument a method description.   A method description is a textual representation that can be used to uniquely identify a method.   The syntax is as follows: [namespace]classname:methodname[(arguments)]
The values in brackets are optional, like the namespace and the arguments.   The arguments themselves are either empty, or a comma- separated list of arguments.   Both the classname and methodname can be set to the special value '*' to match any values (Unix shell users should escape the argument to avoid the shell interpreting this).
The arguments, if present should be a comma separated list of types either a full typename, or for built-in types it should use the low-level ILAsm type names for the built-in types, like 'void', 'char', 'bool', 'byte', 'sbyte', 'uint16', 'int16', 'uint',
Pointer types should be the name of the type, followed by a '*', arrays should be the typename followed by '[' one or more commas (to indicate the rank of the array), and ']'.
Generic values should use '<', one or more type names, separated by both a comma and a space and '>'.
By-reference arguments should include a "&" after the typename.
Examples: *:ctor(int)         // All constructors that take an int as an argument *:Main              // Methods named Main in any class *:Main(string[])    // Methods named Main that take a string array in any class
--aot, --aot[=options] This option is used to precompile the CIL code in the specified assembly to native code.  The generated code is stored in a file with the extension .so.  This file will be automatically picked up by the runtime when the assembly is executed.  Ahead-of-Time compilation is most useful if you use it in combination with the -O=all,-shared flag which enables all of the optimizations in the code generator to be performed.  Some of those optimizations are not practical for Just-in-Time compilation since they might be very time consuming.  Unlike the .NET Framework, Ahead-of-Time compilation will not generate domain independent code: it generates the same code that the Just-in-Time compiler would produce.   Since most applications use a single domain, this is fine.   If you want to optimize the generated code for use in multi-domain applications, consider using the -O=shared flag. This pre-compiles the methods, but the original assembly is still required to execute as this one contains the metadata and exception information which is not available on the generated file.  When precompiling code, you might want to compile with all optimizations (-O=all).  Pre-compiled code is position independent code.  Precompilation is just a mechanism to reduce startup time, increase code sharing across multiple mono processes and avoid just-in-time compilation program startup costs.  The original assembly must still be present, as the metadata is contained there.  AOT code typically can not be moved from one computer to another (CPU-specific optimizations that are detected at runtime) so you should not try to move the pre-generated assemblies or package the pre-generated assemblies for deployment.  A few options are available as a parameter to the --aot command line option.   The options are separated by commas, and more than one can be specified:
asmonly Instructs the AOT compiler to output assembly code instead of an object file.
bind-to-runtime-version If specified, forces the generated AOT files to be bound to the runtime version of the compiling Mono.   This will prevent the AOT files from being consumed by a different Mono runtime.
data-outfile=FILE.dll.aotdata This instructs the AOT code generator to output certain data constructs into a separate file.   This can reduce the executable images some five to twenty percent.   Developers need to then ship the resulting aotdata as a resource and register a hook to load the data on demand by using the mono_install_load_aot_data_hook method.
direct-icalls When this option is specified, icalls (internal calls made from the standard library into the mono runtime code) are invoked directly instead of going through the operating system symbol lookup operation.  This requires use of the static option.
direct-pinvoke When this option is specified, P/Invoke methods are invoked directly instead of going through the operating system symbol lookup operation.  This requires use of the static option.
dwarfdebug Instructs the AOT compiler to emit DWARF debugging information. When used together with the nodebug option, only DWARF debugging information is emitted, but not the information that can be used at runtime.
full   This creates binaries which can be used with the --full-aot option.
hybrid This creates binaries which can be used with the --hybrid- aot option.
llvm   AOT will be performed with the LLVM backend instead of the Mono backend where possible. This will be slower to compile but most likely result in a performance improvement.
llvmonly AOT will be performed with the LLVM backend exclusively and the Mono backend will not be used. The only output in this mode will be the bitcode file normally specified with the llvm-outfile option. Use of llvmonly automatically enables the full and llvm options. This feature is experimental.
llvmopts=[options] Use this option to add more flags to the built-in set of flags passed to the LLVM optimizer.   When you invoke the mono command with the --aot=llvm it displays the current list of flags that are being passed to the opt command. The list of possible flags that can be passed can be obtained by calling the bundled opt program that comes with Mono, and calling it like this:
opt --help
llvmllc=[options] Use this option to add more flags to the built-in set of flags passed to the LLVM static compiler (llc).   The list of possible flags that can be passed can be obtained by calling the bundled llc program that comes with Mono, and calling it like this:
llc --help
mcpu=[native o generic] cpu=native allows AOT mode to use all instructions current CPU supports, e.g. AVX2, SSE42, etc.  Default value is 'generic'.  mattr=[cpu feature] Allows AOT code generator to use specified CPU features where possible including `System.Runtime.Intrinsics.*'.  E.g. `mattr=+avx2,mattr=-lzcnt' unlocks sse1-4.2, avx1-2 and disables lzcnt.  It's useful for cross-compilation or when it's not possible to use `-mcpu=native' (which enables all cpu feature current cpu has).  llvm-outfile=[filename] Gives the path for the temporary LLVM bitcode file created during AOT.  dedup Each AOT module will typically contain the code for inflated methods and wrappers that are called by code in that module. In dedup mode, we identify and skip compiling all of those methods. When using this mode with fullaot, dedup-include is required or these methods will remain missing.
dedup-include=[filename] In dedup-include mode, we are in the pass of compilation where we compile the methods that we had previously skipped. All of them are emitted into the assembly that is passed as this option. We consolidate the many duplicate skipped copies of the same method into one.
info   Print the architecture the AOT in this copy of Mono targets and quit.
interp Generates all required wrappers, so that it is possible to run --interpreter without any code generation at runtime. This option only makes sense with mscorlib.dll.  Embedders can set
depfile=[filename] Outputs a gcc -M style dependency file.
mono_jit_set_aot_mode (MONO_AOT_MODE_INTERP);
ld-flags Additional flags to pass to the C linker (if the current AOT mode calls for invoking it).
llvm-path=<PREFIX> Same for the llvm tools 'opt' and 'llc'.
msym-dir=<PATH> Instructs the AOT compiler to generate offline sequence points .msym files.  The generated .msym files will be stored into a subfolder of <PATH> named as the compilation AOTID.
mtriple=<TRIPLE> Use the GNU style target triple <TRIPLE> to determine some code generation options, i.e.  --mtriple=armv7-linux- gnueabi will generate code that targets ARMv7. This is currently only supported by the ARM backend. In LLVM mode, this triple is passed on to the LLVM llc compiler.
nimt-trampolines=[number] When compiling in full aot mode, the IMT trampolines must be precreated in the AOT image.  You can add additional method trampolines with this argument.  Defaults to 512.
ngsharedvt-trampolines=[number] When compiling in full aot mode, the value type generic sharing trampolines must be precreated in the AOT image. You can add additional method trampolines with this argument.  Defaults to 512.
nodebug Instructs the AOT compiler to not output any debugging information.
no-direct-calls This prevents the AOT compiler from generating a direct calls to a method.   The AOT compiler usually generates direct calls for certain methods that do not require going through the PLT (for example, methods that are known to not require a hook like a static constructor) or call into simple internal calls.
nrgctx-trampolines=[number] When compiling in full aot mode, the generic sharing trampolines must be precreated in the AOT image.  You can add additional method trampolines with this argument. Defaults to 4096.
nrgctx-fetch-trampolines=[number] When compiling in full aot mode, the generic sharing fetch trampolines must be precreated in the AOT image.  You can add additional method trampolines with this argument. Defaults to 128.
ntrampolines=[number] When compiling in full aot mode, the method trampolines must be precreated in the AOT image.  You can add additional method trampolines with this argument.  Defaults to 4096.
outfile=[filename] Instructs the AOT compiler to save the output to the specified file.
print-skipped-methods If the AOT compiler cannot compile a method for any reason, enabling this flag will output the skipped methods to the console.
profile=[file] Specify a file to use for profile-guided optimization. See the AOT profiler sub-section. To specify multiple files, include the profile option multiple times.
profile-only AOT *only* the methods described in the files specified with the profile option. See the AOT profiler sub-section.
readonly-value=namespace.typename.fieldname=type/value Override the value of a static readonly field. Usually, during JIT compilation, the static constructor is ran eagerly, so the value of a static readonly field is known at compilation time and the compiler can do a number of optimizations based on it. During AOT, instead, the static constructor can't be ran, so this option can be used to set the value of such a field and enable the same set of optimizations.  Type can be any of i1, i2, i4 for integers of the respective sizes (in bytes).  Note that signed/unsigned numbers do not matter here, just the storage size.  This option can be specified multiple times and it doesn't prevent the static constructor for the type defining the field to execute with the usual rules at runtime (hence possibly computing a different value for the field).
save-temps,keep-temps Instructs the AOT compiler to keep temporary files.
soft-debug This instructs the compiler to generate sequence point checks that allow Mono's soft debugger to debug applications even on systems where it is not possible to set breakpoints or to single step (certain hardware configurations like the cell phones and video gaming consoles).
static Create an ELF object file (.o) or .s file which can be statically linked into an executable when embedding the mono runtime. When this option is used, the object file needs to be registered with the embedded runtime using the mono_aot_register_module function which takes as its argument the mono_aot_module_<ASSEMBLY NAME>_info global symbol from the object file:
extern void *mono_aot_module_hello_info;
mono_aot_register_module (mono_aot_module_hello_info);
stats  Print various stats collected during AOT compilation.
temp-path=[path] Explicitly specify path to store temporary files created during AOT compilation.
threads=[number] This is an experimental option for the AOT compiler to use multiple threads when compiling the methods.
tool-prefix=<PREFIX> Prepends <PREFIX> to the name of tools ran by the AOT compiler, i.e. 'as'/'ld'. For example, --tool=prefix=arm- linux-gnueabi- will make the AOT compiler run
ld-name=NAME One of the tools used for AOT builds is the linker. Its name differs between various systems and it may happen that the assumed default name of the binary is not present.  If the toolchain used does not have a linker with the default name (e.g. Android NDK r22 does not have the default 'ld' linker prefixed with 'tool-prefix' above, instead it has prefixed 'ld.gold' and 'ld.bfd' linkers) this option can be used to set the linker binary name. It will be prefixed with 'tool-prefix' to form the full linker executable name.
verbose Prints additional information about type loading failures.
write-symbols,no-write-symbols Instructs the AOT compiler to emit (or not emit) debug symbol information.
no-opt Instructs the AOT compiler tot no call opt when compiling with LLVM.
For more information about AOT, see: http://www.mono- project.com/docs/advanced/aot/
--aot-path=PATH List of additional directories to search for AOT images.
--apply-bindings=FILE Apply the assembly bindings from the specified configuration file when running the AOT compiler.  This is useful when compiling an auxiliary assembly that is referenced by a main assembly that provides a configuration file.  For example, if app.exe uses lib.dll then in order to make the assembly bindings from app.exe.config available when compiling lib.dll ahead of time, use: mono --apply-bindings=app.exe.config --aot lib.dll