commands:
- name: autorecovery
  description: Enable or disable autorecovery in the cluster.
  options:
  - flag: -enable
    description: Enable autorecovery of underreplicated ledgers
  - flag: -disable
    description: Disable autorecovery of underreplicated ledgers
- name: bookieformat
  description: Format the current server contents.
  options:
  - flag: -nonInteractive
    description: Whether to confirm if old data exists.
  - flag: -force
    description: If [nonInteractive] is specified, then whether to force delete the old data without prompt..?
  - flag: -deleteCookie
    description: Delete its cookie on zookeeper
- name: initbookie
  description: |
    Initialize new bookie, by making sure that the journalDir, ledgerDirs and
    indexDirs are empty and there is no registered Bookie with this BookieId.

    If there is data present in current bookie server, the init operation will fail. If you want to format
    the bookie server, use `bookieformat`.
- name: bookieinfo
  description: Retrieve bookie info such as free and total disk space.
- name: bookiesanity
  description: Sanity test for local bookie. Create ledger and write/read entries on the local bookie.
  options:
  - flag: -entries N
    description: Total entries to be added for the test (default 10)
  - flag: -timeout N
    description: Timeout for write/read operations in seconds (default 1)
- name: decommissionbookie
  description: Force trigger the Audittask and make sure all the ledgers stored in the decommissioning bookie are replicated.
- name: deleteledger
  description: Delete a ledger
  options:
  - flag: -ledgerid N
    description: Ledger ID
  - flag: -force
    description: Whether to force delete the Ledger without prompt..?
- name: expandstorage
  description: Add new empty ledger/index directories. Update the directories info in the conf file before running the command.
- name: help
  description: Displays the help message.
- name: lastmark
  description: Print last log marker.
- name: ledger
  description: Dump ledger index entries into readable format.
  options:
  - flag: -m LEDGER_ID
    description: Print meta information
- name: ledgermetadata
  description: Print the metadata for a ledger.
  options:
  - flag: -ledgerid N
    description: Ledger ID
- name: listbookies
  description: List the bookies, which are running as either readwrite or readonly mode.
  options:
  - flag: -readwrite
    description: Print readwrite bookies
  - flag: -readonly
    description: Print readonly bookies
  - flag: -hostnames
    description: Also print hostname of the bookie
- name: listfilesondisc
  description: List the files in JournalDirectory/LedgerDirectories/IndexDirectories.
  options:
  - flag: -journal
    description: Print list of journal files
  - flag: -entrylog
    description: Print list of entryLog files
  - flag: -index
    description: Print list of index files
- name: listledgers
  description: List all ledgers in the cluster (this may take a long time).
  options:
  - flag: -meta
    description: Print metadata
- name: listunderreplicated
  description: List ledgers marked as underreplicated, with optional options to specify missing replica (BookieId) and to exclude missing replica.
  options:
  - flag: -missingreplica N
    description: Bookie Id of missing replica
  - flag: -excludingmissingreplica N
    description: Bookie Id of missing replica to ignore
  - flag: -printmissingreplica
    description: Whether to print missingreplicas list?
- name: metaformat
  description: |
    Format Bookkeeper metadata in Zookeeper. This command is deprecated since 4.7.0,
    in favor of using `initnewcluster` for initializing a new cluster and `nukeexistingcluster` for nuking an existing cluster.
  options:
  - flag: -nonInteractive
    description: Whether to confirm if old data exists..?
  - flag: -force
    description: If [nonInteractive] is specified, then whether to force delete the old data without prompt.
- name: initnewcluster
  description: |
    Initializes a new bookkeeper cluster. If initnewcluster fails then try nuking
    existing cluster by running nukeexistingcluster before running initnewcluster again
- name: nukeexistingcluster
  description: Nuke bookkeeper cluster by deleting metadata
  options:
  - flag: -zkledgersrootpath
    description: zookeeper ledgers rootpath
  - flag: -instanceid
    description: instance id
  - flag: -force
    description: If instanceid is not specified, then whether to force nuke the metadata without validating instanceid
- name: lostbookierecoverydelay
  description: Setter and Getter for LostBookieRecoveryDelay value (in seconds) in Zookeeper.
  options:
  - flag: -get
    description: Get LostBookieRecoveryDelay value (in seconds)
  - flag: -set N
    description: Set LostBookieRecoveryDelay value (in seconds)
- name: readjournal
  description: Scan a journal file and format the entries into readable format.
  options:
  - flag: -msg JOURNAL_ID|JOURNAL_FILENAME
    description: Print message body
  - flag: -dir
    description: Journal directory (needed if more than one journal configured)
- name: readledger
  description: Read a range of entries from a ledger.
  argument: <ledger_id> [<start_entry_id> [<end_entry_id>]]
- name: readlog
  description: Scan an entry file and format the entries into readable format.
  argument: <entry_log_id | entry_log_file_name>
  options:
  - flag: -msg
    description: Print message body
  - flag: -ledgerid N
    description: Ledger ID
  - flag: -entryid N
    description: Entry ID
  - flag: -startpos N
    description: Start Position
  - flag: -endpos
    description: End Position
- name: recover
  description: Recover the ledger data for failed bookie.
  argument: <bookieSrc> [<bookieDest>]
  options:
  - flag: -deleteCookie
    description: Delete cookie node for the bookie.
- name: simpletest
  description: Simple test to create a ledger and write entries to it.
  options:
  - flag: -ensemble N
    description: Ensemble size (default 3)
  - flag: -writeQuorum N
    description: Write quorum size (default 2)
  - flag: ackQuorum N
    description: Ack quorum size (default 2)
  - flag: -numEntries N
    description: Entries to write (default 1000)
- name: triggeraudit
  description: Force trigger the Audit by resetting the lostBookieRecoveryDelay.
- name: updatecookie
  description: Update bookie id in cookie.
  options:
  - flag: -bookieId <hostname|ip>
    description: Bookie Id
- name: updateledgers
  description:  Update bookie id in ledgers (this may take a long time).
  options:
  - flag: -bookieId <hostname|ip>
    description: Bookie Id
  - flag: -updatespersec N
    description: Number of ledgers updating per second (default 5 per sec)
  - flag: -limit N
    description: Maximum number of ledgers to update (default no limit)
  - flag: -verbose
    description: Print status of the ledger updation (default false)
  - flag: -printprogress N
    description: Print messages on every configured seconds if verbose turned on (default 10 secs)
- name: whoisauditor
  description: Print the node which holds the auditor lock
- name: whatisinstanceid
  description: Print the instanceid of the cluster
- name: convert-to-db-storage
  description: Convert bookie indexes from InterleavedStorage to DbLedgerStorage format
- name: convert-to-interleaved-storage
  description: Convert bookie indexes from DbLedgerStorage to InterleavedStorage format
- name: rebuild-db-ledger-locations-index
  description: Rebuild DbLedgerStorage locations index
