def add_node_red(force):
"""
Create a service for Node-RED.
"""
utils.check_config()
utils.confirm_mode()
name = 'node-red'
sudo = utils.optsudo()
host = utils.host_ip()
port = utils.getenv(const.HTTPS_PORT_KEY)
config = utils.read_compose()
if not force:
check_duplicate(config, name)
config['services'][name] = {
'image': 'brewblox/node-red:${BREWBLOX_RELEASE}',
'restart': 'unless-stopped',
'volumes': [{
'type': 'bind',
'source': f'./{name}',
'target': '/data',
}]
}
sh(f'mkdir -p ./{name}')
if [getgid(), getuid()] != [1000, 1000]:
sh(f'sudo chown -R 1000:1000 ./{name}')
utils.write_compose(config)
click.echo(f'Added Node-RED service `{name}`.')
if utils.confirm('Do you want to run `brewblox-ctl up` now?'):
sh(f'{sudo}docker-compose up -d')
click.echo(f'Visit https://{host}:{port}/{name} in your browser to load the editor.')
def add_plaato(name, token, force):
"""
Create a service for the Plaato airlock.
This will periodically query the Plaato server for current state.
An authentication token is required.
See https://plaato.io/apps/help-center#!hc-auth-token on how to get one.
"""
utils.check_config()
utils.confirm_mode()
sudo = utils.optsudo()
config = utils.read_compose()
if not force:
check_duplicate(config, name)
config['services'][name] = {
'image': 'brewblox/brewblox-plaato:${BREWBLOX_RELEASE}',
'restart': 'unless-stopped',
'environment': {
'PLAATO_AUTH': token,
},
'command': f'--name={name}',
}
utils.write_compose(config)
click.echo(f'Added Plaato service `{name}`.')
click.echo('This service publishes history data, but does not have a UI component.')
if utils.confirm('Do you want to run `brewblox-ctl up` now?'):
sh(f'{sudo}docker-compose up -d')
def apply_config_files():
"""Apply system-defined configuration from config dir"""
utils.info('Updating configuration files...')
sh(f'cp -f {const.CONFIG_DIR}/traefik-cert.yaml ./traefik/')
sh(f'cp -f {const.CONFIG_DIR}/docker-compose.shared.yml ./')
shared_cfg = utils.read_shared_compose()
usr_cfg = utils.read_compose()
usr_cfg['version'] = shared_cfg['version']
utils.write_compose(usr_cfg)
def check_automation_ui():
# The automation service is deprecated, and its editor is removed from the UI.
# The service was always optional - only add the automation-ui service if automation is present.
config = utils.read_compose()
services = config['services']
if 'automation' in services and 'automation-ui' not in services:
utils.info('Adding automation-ui service...')
services['automation-ui'] = {
'image': 'brewblox/brewblox-automation-ui:${BREWBLOX_RELEASE}',
'restart': 'unless-stopped',
}
utils.write_compose(config)
def migrate_compose_datastore():
# The couchdb datastore service is gone
# Older services may still rely on it
utils.info('Removing `depends_on` fields from docker-compose.yml...')
config = utils.read_compose()
for svc in config['services'].values():
with suppress(KeyError):
del svc['depends_on']
utils.write_compose(config)
# Init dir. It will be filled during upped_migrate
utils.info('Creating redis/ dir...')
sh('mkdir -p redis/')
def discover_spark(discovery_type):
"""
Discover available Spark controllers.
This prints device ID for all devices, and IP address for Wifi devices.
If a device is connected over USB, and has Wifi active, it may show up twice.
Multicast DNS (mDNS) is used for Wifi discovery.
Whether this works is dependent on the configuration of your router and avahi-daemon.
"""
try:
config = utils.read_compose()
except FileNotFoundError:
config = {}
list_devices(discovery_type, config)
def remove(ctx, services):
"""Remove a service."""
utils.check_config()
utils.confirm_mode()
config = utils.read_compose()
for name in services:
try:
del config['services'][name]
utils.info(f"Removed service '{name}'")
except KeyError:
utils.warn(f"Service '{name}' not found")
if services:
utils.write_compose(config)
restart_services(ctx, compose_args=['--remove-orphans'])
def expose(ctx, delete, service, value):
"""Add exposed port to docker-compose.yml for backend service"""
config = utils.read_compose()
ports = nested_setdefault(config, [('services', {}), (service, {}),
('ports', [])])
if (value in ports) ^ delete:
return # already in desired state
if delete:
ports.remove(value)
else:
ports.append(value)
config['services'] = clean_empty(config['services'])
utils.write_compose(config)
restart_services(ctx)
def add_tilt(force):
"""
Create a service for the Tilt hydrometer.
The service listens for Bluetooth status updates from the Tilt,
and requires the host to have a Bluetooth receiver.
The empty ./tilt dir is created to hold calibration files.
"""
utils.check_config()
utils.confirm_mode()
name = 'tilt'
sudo = utils.optsudo()
config = utils.read_compose()
if not force:
check_duplicate(config, name)
config['services'][name] = {
'image': 'brewblox/brewblox-tilt:${BREWBLOX_RELEASE}',
'restart': 'unless-stopped',
'privileged': True,
'network_mode': 'host',
'volumes': [{
'type': 'bind',
'source': f'./{name}',
'target': '/share',
}],
'labels': [
'traefik.enable=false',
],
}
sh(f'mkdir -p ./{name}')
utils.write_compose(config)
click.echo(f'Added Tilt service `{name}`.')
click.echo('It will automatically show up in the UI.\n')
if utils.confirm('Do you want to run `brewblox-ctl up` now?'):
sh(f'{sudo}docker-compose up -d')
def migrate_compose_split():
# Splitting compose configuration between docker-compose and docker-compose.shared.yml
# Version pinning (0.2.2) will happen automatically
utils.info('Moving system services to docker-compose.shared.yml...')
config = utils.read_compose()
sys_names = [
'mdns',
'eventbus',
'influx',
'datastore',
'history',
'ui',
'traefik',
]
usr_config = {
'version': config['version'],
'services': {
key: svc
for (key, svc) in config['services'].items()
if key not in sys_names
}
}
utils.write_compose(usr_config)
def save(save_compose, ignore_spark_error):
"""Create a backup of Brewblox settings.
A zip archive containing JSON/YAML files is created in the ./backup/ directory.
The archive name will include current date and time to ensure uniqueness.
Restrictions:
- The backup is not exported to any kind of remote/cloud storage.
- The backup does not include history data.
- The backup does not include Docker images.
- The backup does not include custom configuration for third-party services.
To use this command in scripts, run it as `brewblox-ctl --quiet backup save`.
Its only output to stdout will be the absolute path to the created backup.
The command will fail if any of the Spark services could not be contacted.
As it does not make any destructive changes to configuration,
this command is not affected by --dry-run.
\b
Stored data:
- .env
- docker-compose.yml. (Optional)
- Datastore databases.
- Spark service blocks.
- Node-RED data.
- Mosquitto config files.
- Tilt config files.
\b
NOT stored:
- History data.
"""
utils.check_config()
urllib3.disable_warnings()
file = f'backup/brewblox_backup_{datetime.now().strftime("%Y%m%d_%H%M")}.zip'
with suppress(FileExistsError):
mkdir(Path('backup/').resolve())
store_url = utils.datastore_url()
utils.info('Waiting for the datastore...')
http.wait(store_url + '/ping', info_updates=True)
config = utils.read_compose()
sparks = [
k for k, v in config['services'].items()
if v.get('image', '').startswith('brewblox/brewblox-devcon-spark')
]
zipf = zipfile.ZipFile(file, 'w', zipfile.ZIP_DEFLATED)
# Always save .env
utils.info('Exporting .env')
zipf.write('.env')
# Always save datastore
utils.info('Exporting datastore')
resp = requests.post(store_url + '/mget',
json={
'namespace': '',
'filter': '*'
},
verify=False)
resp.raise_for_status()
zipf.writestr('global.redis.json', resp.text)
if save_compose:
utils.info('Exporting docker-compose.yml')
zipf.write('docker-compose.yml')
for spark in sparks:
utils.info(f'Exporting Spark blocks from `{spark}`')
resp = requests.post(f'{utils.host_url()}/{spark}/blocks/backup/save',
verify=False)
try:
resp.raise_for_status()
zipf.writestr(spark + '.spark.json', resp.text)
except Exception as ex:
if ignore_spark_error:
utils.info(f'Skipping Spark `{spark}` due to error: {str(ex)}')
else:
raise ex
for fname in [
*glob('node-red/*.js*'),
*glob('node-red/lib/**/*.js*'),
*glob('mosquitto/*.conf'),
*glob('tilt/*'),
]:
zipf.write(fname)
zipf.close()
click.echo(Path(file).resolve())
utils.info('Done!')
def log(add_compose, add_system, upload):
"""Generate and share log file for bug reports.
This command generates a comprehensive report on current system state and logs.
When reporting bugs, a termbin blink to the output is often the first thing asked for.
For best results, run when the services are still active.
Service logs are discarded after `brewblox-ctl down`.
Care is taken to prevent accidental leaks of confidential information.
Only known variables are read from .env,
and the `--no-add-compose` flag allows skipping compose configuration.
The latter is useful if the configuration contains passwords or tokens.
To review or edit the output, use the `--no-upload` flag.
The output will include instructions on how to manually upload the file.
\b
Steps:
- Create ./brewblox.log file.
- Append Brewblox .env variables.
- Append software version info.
- Append service logs.
- Append content of docker-compose.yml (optional).
- Append content of docker-compose.shared.yml (optional).
- Append blocks from Spark services.
- Append system diagnostics.
- Upload file to termbin.com for shareable link (optional).
"""
utils.check_config()
utils.confirm_mode()
sudo = utils.optsudo()
# Create log
utils.info(f"Log file: {Path('./brewblox.log').resolve()}")
create()
append('date')
# Add .env values
utils.info('Writing Brewblox .env values...')
header('.env')
for key in ENV_KEYS:
append(f'echo "{key}={utils.getenv(key)}"')
# Add version info
utils.info('Writing software version info...')
header('Versions')
append('uname -a')
append('python3 --version')
append(f'{sudo}docker --version')
append(f'{sudo}docker-compose --version')
# Add active containers
utils.info('Writing active containers...')
header('Containers')
append(f'{sudo}docker-compose ps -a')
# Add service logs
try:
config_names = list(utils.read_compose()['services'].keys())
shared_names = list(utils.read_shared_compose()['services'].keys())
names = [n for n in config_names if n not in shared_names] + shared_names
for name in names:
utils.info(f'Writing {name} service logs...')
header(f'Service: {name}')
append(f'{sudo}docker-compose logs --timestamps --no-color --tail 200 {name}')
except Exception as ex:
append('echo ' + shlex.quote(type(ex).__name__ + ': ' + str(ex)))
# Add compose config
if add_compose:
utils.info('Writing docker-compose configuration...')
header('docker-compose.yml')
append('cat docker-compose.yml')
header('docker-compose.shared.yml')
append('cat docker-compose.shared.yml')
else:
utils.info('Skipping docker-compose configuration...')
# Add blocks
host_url = utils.host_url()
services = utils.list_services('brewblox/brewblox-devcon-spark')
for svc in services:
utils.info(f'Writing {svc} blocks...')
header(f'Blocks: {svc}')
append(f'{const.CLI} http post --pretty {host_url}/{svc}/blocks/all/read')
# Add system diagnostics
if add_system:
utils.info('Writing system diagnostics...')
header('docker info')
append(f'{sudo}docker info')
header('journalctl -u docker')
append('sudo journalctl -u docker | tail -100')
header('journalctl -u avahi-daemon')
append('sudo journalctl -u avahi-daemon | tail -100')
header('disk usage')
append('df -hl')
header('/var/log/syslog')
append('sudo tail -n 500 /var/log/syslog')
header('dmesg')
append('dmesg -T')
else:
utils.info('Skipping system diagnostics...')
# Upload
if upload:
click.echo(utils.file_netcat('termbin.com', 9999, Path('./brewblox.log')).decode())
else:
utils.info('Skipping upload. If you want to manually upload the log, run: ' +
click.style('brewblox-ctl termbin ./brewblox.log', fg='green'))
def add_spark(name,
discover_now,
device_id,
discovery_type,
device_host,
command,
force,
release,
simulation):
"""
Create or update a Spark service.
If you run brewblox-ctl add-spark without any arguments,
it will prompt you for required info, and then create a sensibly configured service.
If you want to fine-tune your service configuration, multiple arguments are available.
For a detailed explanation: https://brewblox.netlify.com/user/connect_settings.html
"""
# utils.check_config()
utils.confirm_mode()
image_name = 'brewblox/brewblox-devcon-spark'
sudo = utils.optsudo()
config = utils.read_compose()
if not force:
check_duplicate(config, name)
for (nm, svc) in config['services'].items():
img = svc.get('image', '')
cmd = svc.get('command', '')
if not any([
nm == name,
not img.startswith(image_name),
'--device-id' in cmd,
'--device-host' in cmd,
'--simulation' in cmd,
]):
utils.warn(f'The existing Spark service `{nm}` does not have any connection settings.')
utils.warn('It will connect to any controller it can find.')
utils.warn('This may cause multiple services to connect to the same controller.')
utils.warn(f'To reconfigure `{nm}`, please run:')
utils.warn('')
utils.warn(f' brewblox-ctl add-spark -f --name {nm}')
utils.warn('')
utils.select('Press ENTER to continue or Ctrl-C to exit')
if discover_now and not simulation and not device_id:
if device_host:
dev = find_device_by_host(device_host)
else:
dev = choose_device(discovery_type, config)
if dev:
device_id = dev['id']
else:
# We have no device ID, and no device host. Avoid a wildcard service
click.echo('No valid combination of device ID and device host.')
raise SystemExit(1)
commands = [
'--name=' + name,
'--discovery=' + discovery_type,
]
if device_id:
commands += ['--device-id=' + device_id]
if device_host:
commands += ['--device-host=' + device_host]
if simulation:
commands += ['--simulation']
if command:
commands += [command]
config['services'][name] = {
'image': f'{image_name}:{utils.docker_tag(release)}',
'privileged': True,
'restart': 'unless-stopped',
'command': ' '.join(commands)
}
if simulation:
mount_dir = f'simulator__{name}'
config['services'][name]['volumes'] = [{
'type': 'bind',
'source': f'./{mount_dir}',
'target': '/app/simulator'
}]
sh(f'mkdir -m 777 -p {mount_dir}')
utils.write_compose(config)
click.echo(f'Added Spark service `{name}`.')
click.echo('It will automatically show up in the UI.\n')
if utils.confirm('Do you want to run `brewblox-ctl up` now?'):
sh(f'{sudo}docker-compose up -d')
