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 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_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 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 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)