AaronFiore/docker-finance
1
0
Fork 0
forked from EvergreenCrypto/docker-finance
Code Activity
573 Commits 1 Branch 10 Tags
3a35e45ffaf8af92b2b55158ecfbf1e65b3291ed
Go to file
Clone
Open with VS Code Open with VSCodium Open with Intellij IDEA
Download ZIP Download TAR.GZ Download BUNDLE

README.md

Looking for a Quickstart? Skip to Installation.

  1. What does it do?
  2. What is supported?
  3. How do I get started?
  4. How do I use it?
  5. How do I contribute?
  6. How do I connect?
  7. Where is the legalese?

What does it do?

Cryptocurrency, legacy banking, tax preparation, metadata analysis & more!

Overview

docker-finance gives you the power of a privacy-focused, highly uniform system of financial management - but with a modern twist.

Cryptocurrencies & blockchain metadata are unified with legacy finance to create a world of best-practice accounting in a highly flexible, time-tested environment.

Highlights

Screenshots

Client (Host)

The docker in docker-finance.

image: finance (docker-finance)

image: dev-tools

Container

The finance in docker-finance.

Fetch

Ledger (command)

Meta (w/ ROOT C++ analysis)

ROOT (CLI w/ C++ API)

Taxes

Reports

Help (suite of commands)

What is supported?

Plaintext accounting gives you the power to manage any number of assets or accounts.

However, for accounts that require fetch/import functionality, only the following are supported:

CeFi

Regularly maintained

Available but requires community maintenance

Available but no longer maintained

  • Bittrex (bankrupt [US] / wind down [Global])
  • BlockFi (bankrupt)
  • Celsius Network (bankrupt)
  • Coinbase Pro ("sunsetted")

DeFi

Blockchain explorers / Ecosystems

Supported blockchains (independent of wallet type):

Self-hosting

Wallets

Software
Hardware
Web

TradFi

Regularly maintained

Requires community maintenance

NonFi

Cloud Services

Prices

How do I get started?

Installation

docker-finance is not your typical Docker image in which you simply pull and containerize, but rather it's an image-based accounting system that operates transparently between your client (host) and container; keeping your finances containerized, with all the benefits of containerization.

docker-finance should work out-of-the-box on any modern Linux system. For example, if your client (host) is Ubuntu, the default installation of coreutils, shells and utils that came with your system will satisfy requirements. However, you'll still need to manually install Docker (see below).

  1. Install dependencies:

    1. Docker Engine with post-install configuration
      • Latest version (or at least 27.1.1)
    2. GNU Bash
      • Latest version (or at least 5.0.17)
      • Installed by default on most Linux distributions
    3. Git
      • Latest version (or at least 2.25.1)
      • Only needed for step 3 but should be kept in order to:
        • Remain up-to-date with future docker-finance versions
        • Safely track your workflow related data (journals, metadata, etc.)

  2. Install recommended (optional):

    Although not required, consider the following for workflow efficiency:

    • A terminal multiplexer like tmux or screen
    • A terminal file manager like mc (Midnight Commander)

  3. Prepare your repository:

    Pick a persistent path that you're likely to keep; your environment will be aliased/sourced to the path you choose.

    if hash git &>/dev/null; then
  if [ -d docker-finance ]; then
    if pushd docker-finance &>/dev/null; then
      if ! git pull --tags; then
        echo "FATAL: docker-finance repo not pulled" >&2
      fi
      popd 1>/dev/null
    else
      echo "FATAL: docker-finance repo not found" >&2
    fi
  else
    if ! git clone https://gitea.com/EvergreenCrypto/docker-finance; then
      echo "FATAL: docker-finance repo not cloned" >&2
    fi
  fi
else
  echo "FATAL: git not found" >&2
fi

  4. Verify your repository (optional):

    if pushd docker-finance/ 1>/dev/null; then
  gpg --keyserver hkp://keyserver.ubuntu.com --recv-key 518A22F85BEFD32BCC99C48603F90C4F35E0213E \
    && git verify-commit $(git log -n1 --pretty=format:"%H") \
    && echo -e "\nSUCCESS: now confirm matching key = 518A22F85BEFD32BCC99C48603F90C4F35E0213E" \
    || echo -e "\nFATAL: no key available or possible MITM - do not use!"
  popd 1>/dev/null
fi

  5. Prepare your shell environment:

    The following install convenience aliases and command completion to your shell environment (see install.bash for details).

    ./docker-finance/client/install.bash && source ~/.bashrc
    • After your first image is built (step 7), you can use commandline completion for all docker-finance images and image-based commands
    • The dfi alias of docker-finance is the recommended alias to use for for all client/container operations

  6. Generate client/container environment:

    The following will generate your Docker-related client/container environment for the default image (see Environment Generation for details):

    dfi archlinux/${USER}:default gen all=all

    To regenerate any step in this process, now or in the future, use gen help for available options To use the ubuntu image instead, replace archlinux with ubuntu here and for all remaining steps

  7. Build default docker-finance image:

    dfi archlinux/${USER}:default build type=default

    Use the build help command for available options (such as smaller, faster builds)

  8. Bring up container of default docker-finance image:

    dfi archlinux/${USER}:default up

    You can use tab completion for all dfi <platform/user:tag> commands (but only for built images). See dfi help for commands.

  9. You're inside! See How do I use it? for next steps.

  10. (Optional) Developers: on your client (host), build and setup the dev-tools platform:

    dfi dev-tools/${USER}:default gen all=all && dfi dev-tools/${USER}:default build type=default

Environment Generation

docker-finance's environment consists of two scopes: client and container. The client (host) view is confined to the host while the container view confined to the container (though the client can, at times, view from within the container's perspective).

In terms of configuration, the client (host) has the following files:

  1. The Client (Host) Configuration File (client only)
  2. The Client (Host) Custom Dockerfile (client only)
  3. The Client/Container Superscript (client/container)

You'll create these files (and more) when running client (host) command gen, as seen below.

Tip: client scope can be considered an OOP class which inherits the container as a protected class, with the Client/Container Superscript binding them.

Client Generation

When running gen, you'll see the following:

Client environment file found, backup then generate new one? [Y/n]

Generates the client (host) configuration file (see the Client (Host) Configuration File for details).

  • You can use the generated defaults but make sure your directory layout matches accordingly
  • To easily edit this configuration file after gen is complete, run client (host) command edit type=env

Generating new custom (optional) Dockerfile

Generates custom Dockerfile. Do as you wish; install your own container packages, etc. (see the Client (Host) Custom Dockerfile for details).

  • To easily edit this configuration file after gen is complete, run client (host) command edit type=build

Generate joint client/container superscript? [Y/n]

Select 'y' if this is your first-run for the given platform and tag, or if you need to regenerate the file (see Superscript for details).

Container Generation

After the previous client environment is generated, the following will prepare the container environment (everything you'll need while inside docker-finance).

Generate container finance flow (layout and profiles)? [Y/n]

Not limited to hledger-flow data, this option leads to generating the layout and files needed for processing all docker-finance end-user generated data (journals, configurations, etc.).

Although the container environment is a minimum requirement, here you'll have the option to continue generation.

Enter profile name (e.g., family in 'family/alice') Enter subprofile name (e.g., alice in 'family/alice')

Container generation will always be for a specific profile with subprofile, and here is where you input that information. For example, you could have a family profile with subprofiles of various family members or a business profile with subprofiles of all the various businesses you own.

It should be noted that:

  • all subsequent questions and container generation will relate to this profile/subprofile pairing
  • all output will be sent to the ${DOCKER_FINANCE_CONTAINER_FLOW}/profiles/profile/subprofile path

Generate subprofile's subscript file? [Y/n]

The container's subprofile's shell script is where all subprofile commands and aliases exist.

This file is generated on a per-subprofile basis and all custom code on a per-subprofile basis should go here (see Subscript for details).

Generate subprofile's fetch configuration file? [Y/n]

The container's fetch configuration is what all remote fetching relies on: prices, exchanges, blockchain explorers; all are configured here (see Fetch for details).

Generate subprofile's financial metadata file? [Y/n]

The container's per-subprofile metadata file.

This file contains all your custom metadata and can edited with the edit and analyzed with the meta or root command (see Meta for details).

Generate subprofile's hledger configuration file? [Y/n]

This configuration file is specific to hledger. See hledger documentation for options.

Generate subprofile's hledger-flow accounts? [Y/n]

The container's hledger-flow accounts to be installed. These are the accounts described in What is supported?.

WARNING: if you plan to use blockchain-based wallets (coinbase-wallet, pera-wallet, ledger, metamask, etc.), you MUST generate their respective chains, as seen during generation (algorand, ethereum-based, tezos, etc).

Configuration Files

Client (Host) Configuration

The client (host) configuration file:

  • is located in the ${DOCKER_FINANCE_CLIENT_CONF}/client/env/ directory, with subdirectory format of kernel-machine/platform/tag
    • format consists of username@hostname where username is your host username and hostname is your machine's hostname
  • client/container configurations can be stored on shared NFS/CIFS or related network storage (with applicable user permissions)
    • allows for customizable locations of all container data on any mountable filesystem (as a replacement for Docker Volumes)
  • consists solely of variables in the format DOCKER_FINANCE_VARIABLE=value and is used by both Docker and docker-finance
  • default template variables can be found in gen.bash, as described below

After gen is complete, you can edit this file with the client (host) command: edit type=env (see Client (Host) Command Format).

DOCKER_FINANCE_CLIENT_CONF

Client (host) configuration path. Parent directory for client configuration files.

  • Example: DOCKER_FINANCE_CLIENT_CONF=/home/${USER}/.config/docker-finance.d

DOCKER_FINANCE_CLIENT_FLOW

Client (host) finance-flow path. Parent directory for all profiles and end-user data.

  • Example: DOCKER_FINANCE_CLIENT_FLOW=/net/nfs4/finance-flow

DOCKER_FINANCE_CLIENT_REPO

Client (host) path for the docker-finance code repository (from the host's perspective).

This parent directory is where the client and container directories are located.

  • Example: DOCKER_FINANCE_CLIENT_REPO=/net/nfs4/git/docker-finance

DOCKER_FINANCE_CLIENT_SHARED

Client (host) path for the client/container shared directory.

The bind-mount is used exclusively for non-essential file sharing (custom scripts or any file you wish).

  • Example: DOCKER_FINANCE_CLIENT_SHARED=/mnt/share.d

DOCKER_FINANCE_CLIENT_PLUGINS

Client (host) path for the client/container shared custom plugins.

The bind-mount is used exclusively for user-added plugins not in the repository.

  • Example: DOCKER_FINANCE_CLIENT_PLUGINS=/home/${USER}/Development/dfi_custom-plugins

DOCKER_FINANCE_CONTAINER_CMD

The container's finance command (useful for experimental implementations).

Default: finance.bash (internally aliased to finance and dfi)

  • Example: DOCKER_FINANCE_CONTAINER_CMD=finance.bash

DOCKER_FINANCE_CONTAINER_CONF

The container's configuration path (bind-mounted to client's (host's) configuration path).

  • Example: DOCKER_FINANCE_CONTAINER_CONF=/home/${USER}/.config/docker-finance.d

DOCKER_FINANCE_CONTAINER_EDITOR

The container's default text editor.

  • Example: DOCKER_FINANCE_CONTAINER_EDITOR=vim

DOCKER_FINANCE_CONTAINER_FLOW

The container's finance-flow path from the container's perspective.

This path is bind-mounted to the client's (host's) finance-flow path.

  • Example: DOCKER_FINANCE_CONTAINER_FLOW=/home/${USER}/finance-flow

DOCKER_FINANCE_CONTAINER_REPO

The container's docker-finance code repository path (as viewed from the container).

This path is bind-mounted to the client's (host's) docker-finance/container path.

  • Example: DOCKER_FINANCE_CONTAINER_REPO=/home/${USER}/docker-finance

DOCKER_FINANCE_CONTAINER_SHARED

The container's share.d path, bind-mounted to client's (host's) share.d path.

  • Example: DOCKER_FINANCE_CONTAINER_FLOW=/home/${USER}/share.d

DOCKER_FINANCE_CONTAINER_PLUGINS

The client's custom plugin path (as viewed from the container).

This path is bind-mounted to the client's (host's) ${DOCKER_FINANCE_CLIENT_PLUGINS}/container path.

  • Example: DOCKER_FINANCE_CONTAINER_PLUGINS=/home/${USER}/plugins

DOCKER_FINANCE_CPUS

Docker daemon/container setting: number of CPUs to use.

  • Example: DOCKER_FINANCE_CPUS=2

DOCKER_FINANCE_DEBUG

Enable/disable debugging code paths (i.e., debug logging)

Debug log-levels range from none to most: 0 1 2

  • Example: DOCKER_FINANCE_DEBUG=2

DOCKER_FINANCE_PORT_HLEDGER

hledger-web client-side (host) port

  • Example: DOCKER_FINANCE_PORT_HLEDGER=5000

DOCKER_FINANCE_PORT_ROOT

root client-side (host) port for web interface

  • Example: DOCKER_FINANCE_PORT_ROOT=8080

DOCKER_FINANCE_MEMORY

docker-finance container memory limit (see Docker documentation).

  • Example: 5G

DOCKER_FINANCE_GID

Group ID for bind mount. MUST have write permissions to rw bind-mounts.

  • Example: DOCKER_FINANCE_GID=998

DOCKER_FINANCE_UID

User ID for bind mount. MUST have write permissions to rw bind-mounts.

  • Example: DOCKER_FINANCE_UID=1001

DOCKER_FINANCE_USER

docker-finance container user.

Container user's UID/GID SHOULD match DOCKER_FINANCE_UID and DOCKER_FINANCE_GID. This is automatically determined during Environment Generation.

User MUST have write permissions to rw bind-mounts.

  • Example: DOCKER_FINANCE_USER=alice

Client (Host) Custom Dockerfile

The client (host) custom Dockerfile:

  • is appended to the final generated Dockerfile
    • allows you to append any Dockerfile command to a generated build
  • is located in the ${DOCKER_FINANCE_CLIENT_CONF}/client/Dockerfiles/ directory
    • format consists of username@hostname where username is your host username and hostname is your machine's hostname
  • default generated templates can be found here

After gen is complete, you can edit this file with the client (host) command: edit type=build (see Client (Host) Command Format).

Client/Container Superscript

The client/container shell script (Superscript) is a bind-mounted (by directory) script that:

  • is the intermediary between client and container
  • is unique to each client (host) user (/home/alice, /home/bob, etc.)
  • is the glue that ties together all container Subscript
  • is generated on a per-client basis: all custom code on a per-client basis should go here

See the in-file comments for further documentation:

After gen is complete, you can edit this file with the client (host) command: edit type=shell (see Client (Host) Command Format).

Container Configurations

These configurations are confined solely to the container.

Subscript

The Subprofile's subscript is unique to each subprofile, for each profile/subprofile within the profiles parent directory.

By default, this file will contain user aliases for all container commands. These aliases are mostly useful for small setups or setups with uniquely named subprofiles among all profiles.

See the in-file comments for further documentation:

After gen is complete, from within the container, you can edit this file with: dfi profile/subprofile edit type=shell (see Container Command Format).

Fetch

The source of all remote API fetching configurations (exchanges, blockchains, market prices). This file is used by both the fetch and edit type=fetch commands.

See the in-file comments for further documentation:

After gen is complete, from within the container, you can edit this file with: dfi profile/subprofile edit type=fetch (see Container Command Format).

Meta

The source of all custom metadata information (typically used to store cryptocurrency metadata information). This file is used by the meta, edit type=meta and root commands, as seen in Meta (w/ ROOT C++ analysis).

See the in-file comments for further documentation:

After gen is complete, from within the container, you can edit this file with: dfi profile/subprofile edit type=meta (see Container Command Format).

How do I use it?

Mostly-Unified CLI

You'll only need to call two different scripts throughout your time using docker-finance:

  1. The client script which handles the client-side system: docker.bash
  2. The container script which handles the container-side system: finance.bash

These two scripts can be rationalized by the following format:

<script> <super/sub> <command> [args]

For example, these Screenshots describe a setup with mockup data where the client (host) user named personal, along with container $DOCKER_FINANCE_USER named personal, engage in client/container activity. The container profile named testprofile and its subprofile named testuser can be described as <super/sub> portion of the format (testprofile/testuser).

It should be noted that, for your convenience:

  • command arguments [args] can be arranged in any order
  • commandline completion is available for all <super/sub> command [args] (so, save your fingers and tab away)
    • NOTE: for client, an image must first be built

Client (Host) Command Format

The client (host) command format consists of:

docker.bash <platform/username:tag> <command> [args]

Where:

  • docker.bash is located in ${DOCKER_FINANCE_CLIENT_REPO}/client
  • <platform/username:tag>
    • platform is the image platform (archlinux, ubuntu)
    • username is the client (host) username with read/write permissions to the container (see Configuration Files)
    • tag is a custom tag you can use to delineate any number of images that you wish you create (latest, dev, etc.)
  • <command> is the command to pass to docker.bash
  • [args] are the (optional) arguments to pass to <command>

If the Installation was successful, docker.bash is aliased to docker-finance and dfi (so, either can be used).

For a complete list of commands and usage help (<platform/user:tag> not required):

dfi help

To view the help usage of a specific command, for example; the edit command (<platform/user:tag> is required):

dfi archlinux/${USER}:default edit help

Container Command Format

The container command format consists of:

finance.bash <profile/subprofile> <command> [args]

Where:

  • finance.bash is located in ${DOCKER_FINANCE_CLIENT_REPO}/container
  • <profile/subprofile>
  • <command> is the command to pass to finance.bash
  • [args] are the (optional) arguments to pass to <command>

By default, finance.bash is aliased to finance and dfi (so, either can be used).

For a complete list of commands (<profile/subprofile> not required):

dfi help

To view the help usage of a specific command, for example; the fetch command (<profile/subprofile> is required):

Assuming <profile/subprofile> is testprofile/testuser:

dfi testprofile/testuser fetch help

Or, use a subprofile alias, as described in Subscript:

testuser_fetch help

Flow Layout

A primary read through of hledger and hledger-flow documentation should bring you up to speed on the essentials.

As for docker-finance specifics, you can create a test profile during Environment Generation to see what your flow's layout should look like.

Note: be sure to select 'y' when asked if this will be a development profile, and then go on to create account(s).

Once inside the container, assuming you created a profile named testprofile and subprofile named testuser, issue the following commands:

finance testprofile/testuser fetch all=price year=all && finance testprofile/testuser import year=2018

Note: for this test profile with developer mockups, you MUST import from 2018 as there are accounts that begin from that year

After experimenting with a test profile, you can re-run gen again to create your own normal profile.

Profiles

All profiles/subprofiles are installed into the parent directory ${DOCKER_FINANCE_CONTAINER_FLOW}/profiles.

Peeking inside ${DOCKER_FINANCE_CONTAINER_FLOW}/profiles/profile/subprofile, you'll see the following:

  • all-years.journal and directives.journal

    • These top-level journals are generated by hledger-flow. Ignore these and use the container edit command for all journal editing.

  • docker-finance.d

    • Location of all docker-finance configuration files (see edit help for details).

  • import

    • Location of all CSV data and real journals. This is where you'll place CSV files and custom account/subaccount changes (see edit help for details).

  • prices

    • Location of all market price data, by year, as acquired by fetch price (see fetch help for details).

  • reports

    • Location of all generated reports, by year, as generated by reports (see reports help for details).

  • taxes

    • Location of all generated taxes, by year, as generated by taxes (see taxes help for details).

Note:

  • For manual CSV downloads, place you CSV file into your ${DOCKER_FINANCE_CONTAINER_FLOW}/profiles/profile/subprofile/import/subprofile/account/subaccount/1-in/year directory (replacing year with the year of data that the file/data represents). See import help for details.
  • When you want to edit custom settings for an account or a subaccount, use the container edit command. See container's edit help for details.

Times

All times related files will reside in ${DOCKER_FINANCE_CONTAINER_FLOW}/times (this includes the timewarrior database).

See the container times help command for details.

Caveats & Oddities

Flow Layout

Your finance-flow directory will contain a symlink called src which links to code that processes your data. Do not delete this symlink.

Prices

Before you try to infer market prices, be sure to fetch prices before you do your first import (or first import of the year). If you do not fetch, the prices journal will not be included within the import and, if you have a previous year of prices, you will unwittingly infer against that previous year instead of your expected year!

Accounts: Trezor

In the "Trezor Suite" app, change your wallet name to your subaccount(s). For example, to delineate between your Trezor One from several Trezor T devices, and to delineate between their separate wallets within every device, follow these steps:

Example, using your #2 Trezor T device and one of its BTC "storage" wallets:

  1. Change wallet name in app to t-2:storage-1 as it's your Trezor T device #2, 1st bitcoin wallet named storage-1 (versus your 2nd bitcoin wallet named storage-2, etc.)
  2. Export the CSV file to the appropriate directory. It will be in the format of t_2_storage_1_20230629T230013.csv (timestamp will be different)
  3. Rename the file to t-2:storage-1_BTC.csv (be sure to append the currency ticker to the file. So, _BTC if bitcoin or _LTC if litecoin, etc).

Note: see Trezor mockup data within this repository, for a working example.

docker-finance relies on Amount unit within the file for the actual symbol/currency so, this file naming convention serves at least two purposes:

  1. This allows you to maintain device continuity by reusing wallet names for different currencies.
  2. This allows you to export, in the future, to the correct file from the associated hardware wallet because each hardware wallet exports its own unique CSV.

Taxes

  • If you have a wallets designated for SPENDing/GIFTing or INCOME, you can use custom rules to mark all outgoing/incoming transactions as such (ex., using tags taxed_as:SPEND/taxed_as:GIFT/taxed_as:INCOME/etc.). See implementation for details.
  • WARNING: all GIFTIN cost-basis must be manually entered from the corresponding GIFT results/calculations (as gifted from another).
    • For blockchain-related transactions, you can easily add cost-basis of a gift received (GIFTIN) by TXID in your custom rules
      • Example: despite Electrum providing fiat_value, you'll need to manually enter in your custom rules the correct GIFT value (if divergent)

How do I contribute?

Donate

Time

Your input is valuable and appreciated. Come, make this project your own!

Dependencies

To donate to the wonderful projects that docker-finance gratefully depends upon, please donate to them directly:

For other dependencies, please see their individual contributing guidelines.

Development

You'll greatly benefit from building the dev-tools image, as seen in docker-finance help.

Additionally, when developing with the docker-finance image create a development profile with the gen command argument dev=on. From there, you'll have access to mockup CSVs as described in Flow Layout.

  • In addition to dev=on, run the confirm=off and profile= arguments to quickly spin-up a new development profile
  • Developer mockup CSVs can be found in the mockup directories within the hledger-flow section of this repository
  • Developer mockup CSVs will intentionally have multiple years within in a 1-in/year directory in order to test for year parsing

Plugins

Plugins allow you to use docker-finance public APIs, libraries and environment (client and/or container) to meet your unique needs. These plugins are categorical; as in, there are client-side ("custom") plugins and repository ("repo") plugins. Additionally, there are subcategories such as docker, finance and root (respective to their modules).

Client-side custom plugins allow you to drop-in any code that you write and keep them locally. Repository plugins are plugins that remain within the repository and will require a pull request for any changes to be made. Client-side custom plugins can be used for either client or container modules (see directory layout).

Upon client gen, a client-side directory layout is generated. This layout consists of:

  • ${DOCKER_FINANCE_CLIENT_PLUGINS}/client/docker
    • Custom plugins that function only client-side (lib_docker)
  • ${DOCKER_FINANCE_CLIENT_PLUGINS}/container/{finance,root}
    • Custom plugins that function only container-side (lib_finance, root)

WARNING: don't change the parent client-side directory layout (although, you can add subdirectories):

  • e.g., ${DOCKER_FINANCE_CLIENT_PLUGINS}/container/finance/my_experimental_plugins/{file1.ext,file2.ext}

This client-side "custom" layout somewhat mirrors the repository's plugins layout (see client/plugins and container/plugins).

For more information, see the example plugins and help usage of each module, e.g.; plugins help or help().

Note: for custom plugins within directory docker and finance that utilize the shell, any language can be used so long as the file is executable, reads the shell environment and can initiailize their respective libraries (lib_docker, lib_finance).

Pull Request

The following assumes that the command dev-tools has been properly aliased, per docker-finance help.

Before sending a pull request:

  1. If you created a new file, please run dev-tools license file=/path/to/new/file.ext and update the copyright date and author.
  2. For any work that utilizes Bash/C++/PHP, please run the linter for your respective language (e.g., dev-tools linter type=bash).
    • See dev-tools linter help for details.
  3. As for style guidelines, these are recommended:
  4. If you can, please document the code in Doxygen style where applicable and run dev-tools doxygen gen to see your code documentation.

Notes

  • Regarding client configuration, Docker volumes aren't used because of chicken-or-the-egg problem (among other reasons). docker-finance needs the client environment before building the Docker image and spawning the subsequent container (which would rely on volumes).
  • As described in Mostly-Unified CLI, to use a developer version of the finance image (not a dev-tools image), simply build and tag a new finance image with dev (or whatever you see fit), and reset the docker-finance alias at your discretion.
  • Run DOCKER_FINANCE_DEBUG=true docker-finance <platform/user:tag> <cmd> [args] to debug before the Client (Host) Configuration File file is read.
  • The .C files you see in the repository are ROOT.cern macro files, not C-language files.

How do I connect?

#docker-finance:matrix.org

Join the docker-finance Matrix community.

Evergreen Crypto LLC

Where is the legalese?

License and Disclaimer

docker-finance:

  • is not a Docker product
  • is not a Docker trademark
  • is not an endorsement of what is supported
  • is not a tax-advising product (consult your tax adviser)
  • is not a financial-advising product (consult your financial adviser)
  • is licensed under the GPLv3 but...
View Git Blame Copy Permalink
Description
docker-finance | modern accounting for the power-user
Readme 11 MiB
Languages
Shell 46.2%
C++ 34.3%
PHP 14.5%
C 4.8%
Dockerfile 0.2%