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 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 load(archive, load_env, load_compose, load_datastore, load_spark,
load_node_red, load_mosquitto, load_tilt, update):
"""Load and apply Brewblox settings backup.
This function uses files generated by `brewblox-ctl backup save` as input.
You can use the --load-XXXX options to partially load the backup.
This does not attempt to merge data: it will overwrite current docker-compose.yml,
datastore entries, and Spark blocks.
Blocks on Spark services not in the backup file will not be affected.
If dry-run is enabled, it will echo all configuration from the backup archive.
Steps:
- Write .env
- Read .env values
- Write docker-compose.yml, run `docker-compose up`.
- Write all datastore files found in backup.
- Write all Spark blocks found in backup.
- Write Node-RED config files found in backup.
- Write Mosquitto config files found in backup.
- Run brewblox-ctl update
"""
utils.check_config()
utils.confirm_mode()
urllib3.disable_warnings()
sudo = utils.optsudo()
host_url = utils.host_url()
store_url = utils.datastore_url()
yaml = YAML()
zipf = zipfile.ZipFile(archive, 'r', zipfile.ZIP_DEFLATED)
available = zipf.namelist()
redis_file = 'global.redis.json'
couchdb_files = [v for v in available if v.endswith('.datastore.json')]
spark_files = [v for v in available if v.endswith('.spark.json')]
node_red_files = [v for v in available if v.startswith('node-red/')]
mosquitto_files = [v for v in available if v.startswith('mosquitto/')]
tilt_files = [v for v in available if v.startswith('tilt/')]
if load_env and '.env' in available:
utils.info('Loading .env file')
with NamedTemporaryFile('w') as tmp:
data = zipf.read('.env').decode()
utils.info('Writing .env')
utils.show_data('.env', data)
tmp.write(data)
tmp.flush()
sh(f'cp -f {tmp.name} .env')
utils.info('Reading .env values')
load_dotenv(Path('.env').resolve())
if load_compose:
if 'docker-compose.yml' in available:
utils.info('Loading docker-compose.yml')
config = yaml.load(zipf.read('docker-compose.yml').decode())
# Older services may still depend on the `datastore` service
# The `depends_on` config is useless anyway in a brewblox system
for svc in config['services'].values():
with suppress(KeyError):
del svc['depends_on']
utils.write_compose(config)
sh(f'{sudo}docker-compose up -d')
else:
utils.info('docker-compose.yml file not found in backup archive')
if load_datastore:
if redis_file in available or couchdb_files:
utils.info('Waiting for the datastore...')
sh(f'{const.CLI} http wait {store_url}/ping')
# Wipe UI/Automation, but leave Spark files
mdelete_cmd = '{} http post {}/mdelete --quiet -d \'{{"namespace":"{}", "filter":"*"}}\''
sh(mdelete_cmd.format(const.CLI, store_url, 'brewblox-ui-store'))
sh(mdelete_cmd.format(const.CLI, store_url, 'brewblox-automation'))
else:
utils.info('No datastore files found in backup archive')
if redis_file in available:
data = json.loads(zipf.read(redis_file).decode())
utils.info(
f'Loading {len(data["values"])} entries from Redis datastore')
mset(data)
# Backwards compatibility for UI/automation files from CouchDB
# The IDs here are formatted as {moduleId}__{objId}
# The module ID becomes part of the Redis namespace
for db in ['brewblox-ui-store', 'brewblox-automation']:
fname = f'{db}.datastore.json'
if fname not in available:
continue
docs = json.loads(zipf.read(fname).decode())
# Drop invalid names (not prefixed with module ID)
docs[:] = [d for d in docs if len(d['_id'].split('__', 1)) == 2]
# Add namespace / ID fields
for d in docs:
segments = d['_id'].split('__', 1)
d['namespace'] = f'{db}:{segments[0]}'
d['id'] = segments[1]
del d['_id']
utils.info(f'Loading {len(docs)} entries from database `{db}`')
mset({'values': docs})
# Backwards compatibility for Spark service files
# There is no module ID field here
spark_db = 'spark-service'
spark_fname = f'{spark_db}.datastore.json'
if spark_fname in available:
docs = json.loads(zipf.read(spark_fname).decode())
for d in docs:
d['namespace'] = spark_db
d['id'] = d['_id']
del d['_id']
utils.info(
f'Loading {len(docs)} entries from database `{spark_db}`')
mset({'values': docs})
if load_spark:
sudo = utils.optsudo()
if not spark_files:
utils.info('No Spark files found in backup archive')
for f in spark_files:
spark = f[:-len('.spark.json')]
utils.info(f'Writing blocks to Spark service `{spark}`')
with NamedTemporaryFile('w') as tmp:
data = json.loads(zipf.read(f).decode())
utils.show_data(spark, data)
json.dump(data, tmp)
tmp.flush()
sh(f'{const.CLI} http post {host_url}/{spark}/blocks/backup/load -f {tmp.name}'
)
sh(f'{sudo}docker-compose restart {spark}')
if load_node_red and node_red_files:
sudo = ''
if [getgid(), getuid()] != [1000, 1000]:
sudo = 'sudo '
with TemporaryDirectory() as tmpdir:
zipf.extractall(tmpdir, members=node_red_files)
sh('mkdir -p ./node-red')
sh(f'{sudo}chown 1000:1000 ./node-red/')
sh(f'{sudo}chown -R 1000:1000 {tmpdir}')
sh(f'{sudo}cp -rfp {tmpdir}/node-red/* ./node-red/')
if load_mosquitto and mosquitto_files:
zipf.extractall(members=mosquitto_files)
if load_tilt and tilt_files:
zipf.extractall(members=tilt_files)
zipf.close()
if update:
utils.info('Updating brewblox...')
sh(f'{const.CLI} update')
utils.info('Done!')
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')