def set_completed():
"""Set the first boot process as completed."""
from plinth import kvstore
global _is_completed
_is_completed = True
kvstore.set('firstboot_completed', 1)
def test_get_set(self):
"""Verify that a set value can be retrieved."""
key = 'name'
expected_value = 'Guido'
kvstore.set(key, expected_value)
actual_value = kvstore.get(key)
self.assertEqual(expected_value, actual_value)
def set_completed():
"""Set the first boot process as completed."""
from plinth import kvstore
global _is_completed
_is_completed = True
kvstore.set('firstboot_completed', 1)
def test_get_set():
"""Verify that a set value can be retrieved."""
key = 'name'
expected_value = 'Guido'
kvstore.set(key, expected_value)
actual_value = kvstore.get(key)
assert expected_value == actual_value
def test_get_set(self):
"""Verify that a set value can be retrieved."""
key = 'name'
expected_value = 'Guido'
kvstore.set(key, expected_value)
actual_value = kvstore.get(key)
self.assertEqual(expected_value, actual_value)
def test_get_set_complex_structures(self):
"""Verify that complex structures can be stored and retrieved."""
key = 'compex_structure'
expected_value = {'k1': 1, 'k2': [2, 3], 'k3': 4.5, 'k4': 'Hello',
'k5': {'a': 'b'}}
kvstore.set(key, expected_value)
actual_value = kvstore.get(key)
self.assertEqual(expected_value, actual_value)
def test_get_set_complex_structures(self):
"""Verify that complex structures can be stored and retrieved."""
key = 'compex_structure'
expected_value = {'k1': 1, 'k2': [2, 3], 'k3': 4.5, 'k4': 'Hello',
'k5': {'a': 'b'}}
kvstore.set(key, expected_value)
actual_value = kvstore.get(key)
self.assertEqual(expected_value, actual_value)
def form_valid(self, form):
"""Save value to DB."""
network_topology = form.cleaned_data['network_topology']
logger.info('Updating network topology type with value %s' %
network_topology)
kvstore.set(networks.NETWORK_TOPOLOGY_TYPE_KEY, network_topology)
if network_topology == 'to_router':
self.success_url = reverse_lazy('networks:router-configuration')
return super().form_valid(form)
def mark_step_done(id):
"""Marks the status of a first boot step as done.
:param id: id of the firstboot step
"""
from plinth import kvstore
kvstore.set(id, 1)
if not next_step_or_none():
set_completed()
def mark_step_done(id):
"""Marks the status of a first boot step as done.
:param id: id of the firstboot step
"""
from plinth import kvstore
kvstore.set(id, 1)
if not next_step_or_none():
set_completed()
def state10(request):
"""State 10 is when all firstboot setup is done.
After viewing this page the firstboot module can't be accessed anymore.
"""
# Make sure that a user exists before finishing firstboot
if User.objects.all():
kvstore.set('firstboot_state', 10)
return render_to_response('firstboot_state10.html',
{'title': _('Setup Complete')},
context_instance=RequestContext(request))
def _settings_restore_post(self):
"""Read from a file and restore keys to kvstore."""
if not self.settings:
return
output = actions.superuser_run(
'backups', ['load-settings', '--app-id', self.app_id])
data = json.loads(output)
from plinth import kvstore
for key, value in data.items():
kvstore.set(key, value)
def state10(request):
"""State 10 is when all firstboot setup is done.
After viewing this page the firstboot module can't be accessed anymore.
"""
# Make sure that a user exists before finishing firstboot
if User.objects.all():
kvstore.set('firstboot_state', 10)
connections = network.get_connection_list()
return render(request, 'firstboot_state10.html',
{'title': _('Setup Complete'),
'connections': connections})
def state10(request):
"""State 10 is when all firstboot setup is done.
After viewing this page the firstboot module can't be accessed anymore.
"""
# Make sure that a user exists before finishing firstboot
if User.objects.all():
kvstore.set('firstboot_state', 10)
connections = network.get_connection_list()
return render(request, 'firstboot_state10.html', {
'title': _('Setup Complete'),
'connections': connections
})
def certificate_set_last_seen_modified_time(lineage):
"""Write to store a certificate's last seen expiry date."""
lineage = pathlib.Path(lineage)
output = actions.superuser_run(
'letsencrypt', ['get-modified-time', '--domain', lineage.name])
modified_time = int(output)
from plinth import kvstore
info = kvstore.get_default('letsencrypt_certificate_info', '{}')
info = json.loads(info)
certificate_info = info.setdefault(str(lineage), {})
certificate_info['last_seen_modified_time'] = modified_time
kvstore.set('letsencrypt_certificate_info', json.dumps(info))
def test_backup_restore_backup_pre(run, backup_restore):
"""Test running backup-pre hook."""
packet = None
kvstore.set('setting-1', 'value-1')
backup_restore.app_id = 'testapp'
component = BackupRestore('test-backup-restore')
component.backup_pre(packet)
run.assert_has_calls([])
backup_restore.backup_pre(packet)
input_ = {'setting-1': 'value-1'}
run.assert_has_calls([
call('backups', ['dump-settings', '--app-id', 'testapp'],
input=json.dumps(input_).encode())
])
def update_or_add(storage):
"""Update an existing or create a new repository in store."""
for field in REQUIRED_FIELDS:
if field not in storage:
raise ValueError('missing storage parameter: %s' % field)
existing_storages = get_storages()
if 'uuid' in storage:
# Replace the existing storage
existing_storages[storage['uuid']] = storage
else:
uuid = str(uuid1())
storage['uuid'] = uuid
existing_storages[uuid] = storage
kvstore.set(STORAGE_KEY, json.dumps(existing_storages))
return storage['uuid']
def disable(self):
"""Disable the app by simply storing a flag in key/value store."""
from plinth import kvstore
super().disable()
kvstore.set('wireguard-enabled', False)
utils.enable_connections(False)
def set_advanced_mode(advanced_mode):
"""Turn on/off advanced mode."""
from plinth import kvstore
kvstore.set(ADVANCED_MODE_KEY, advanced_mode)
def delete(uuid):
"""Remove a repository from store."""
storages = get_storages()
del storages[uuid]
kvstore.set(STORAGE_KEY, json.dumps(storages))
def form_valid(self, form):
"""Save value to DB and redirect."""
type_ = form.cleaned_data['router_config']
logger.info('Updating router configuration: %s', type_)
kvstore.set(networks.ROUTER_CONFIGURATION_TYPE_KEY, type_)
return super().form_valid(form)
def get(self, *args, **kwargs):
"""Respond to GET request."""
kvstore.set('firstboot_state', 5)
return super(State5View, self).get(*args, **kwargs)
def set_router_configuration_type(router_configuration_type):
"""Store the router configuration type."""
return kvstore.set('networks_router_configuration_type',
router_configuration_type)
def set_dist_upgrade_enabled(enabled=True):
"""Set whether user has enabled dist upgrade."""
kvstore.set(DIST_UPGRADE_ENABLED_KEY, enabled)
logger.info('Distribution upgrade configured - %s', enabled)
def set_network_topology_type(network_topology_type):
"""Store the network topology type."""
kvstore.set('networks_topology_type', network_topology_type)
def set_backports_requested(requested):
"""Set whether user has chosen to activate backports."""
from plinth import kvstore
kvstore.set(BACKPORTS_REQUESTED_KEY, requested)
logger.info('Backports requested - %s', requested)
def enable(self):
"""Store that the app/component is enabled."""
from plinth import kvstore
kvstore.set(self.key, True)
def set_internet_connection_type(internet_connection_type):
"""Store the internet connection type."""
return kvstore.set('networks_internet_type', internet_connection_type)
def disable(self):
"""Store that the app/component is disabled."""
from plinth import kvstore
kvstore.set(self.key, False)
def get(self, *args, **kwargs):
"""Respond to GET request."""
kvstore.set('firstboot_state', 5)
return super(State5View, self).get(*args, **kwargs)
def form_valid(self, form):
"""Save value to DB and redirect."""
type_ = form.cleaned_data['internet_connection_type']
logger.info('Updating internet connectivity type: %s', type_)
kvstore.set(networks.INTERNET_CONNECTION_TYPE_KEY, type_)
return super().form_valid(form)
