def manage_flags(self): toggle_flag( self.expand_name('{endpoint_name}.available'), all([self.key(), self.fsid(), self.auth(), self.mon_hosts()]))
def get_creds(): prev_creds = layer.openstack.get_credentials() credentials_exist = layer.openstack.update_credentials() toggle_flag('charm.openstack.creds.set', credentials_exist) creds = layer.openstack.get_credentials() if creds != prev_creds: set_flag('charm.openstack.creds.changed')
def restart(): helpers.status_set('maintenance', 'Stopping Cassandra') if not cassandra.stop(): helpers.status_set('blocked', 'Failed to stop Cassandra') return False auth_enabled = cassandra.config()['authenticator'] != 'allowallauthenticator' reactive.toggle_flag('cassandra.auth.enabled', auth_enabled) # cassandra.remount() # TODO: Storage support cassandra.ensure_all_database_directories() helpers.status_set('maintenance', 'Starting Cassandra') if not cassandra.start(): helpers.status_set('blocked', 'Failed to start Cassandra') return False timeout = time.time() + 300 for _ in cassandra.backoff("Cassandra to startup"): if cassandra.is_cassandra_running(): reactive.clear_flag('cassandra.needs_restart') return True if time.time() > timeout: break helpers.status_set('blocked', 'Cassandra failed to startup') return False
def check_refresh_available(): # Do nothing if we don't have kernel support yet if not kernel_supported(): return available_refreshes = snap.get_available_refreshes() for snapname in snap.get_installed_snaps(): toggle_flag(snap.get_refresh_available_flag(snapname), snapname in available_refreshes)
def manage_flags(self): toggle_flag(self.expand_name('{endpoint_name}.connected'), self.is_joined) toggle_flag(self.expand_name('{endpoint_name}.available'), self.config_available()) if is_flag_set(self.expand_name('endpoint.{endpoint_name}.changed')): clear_flag(self.expand_name('{endpoint_name}.configured')) clear_flag(self.expand_name('endpoint.{endpoint_name}.changed'))
def check_ready(self): # My middle name is ready. No, that doesn't sound right. # I eat ready for breakfast. was_ready = is_flag_set(self.expand_name('ready')) toggle_flag(self.expand_name('ready'), self.is_ready) if self.is_ready and was_ready and self.is_changed: set_flag(self.expand_name('ready.changed')) clear_flag(self.expand_name('changed'))
def manage_flags(self): toggle_flag(self.expand_name('{endpoint_name}.connected'), self.is_joined) toggle_flag(self.expand_name('{endpoint_name}.available'), all([self.is_joined, self.unit_role_id, self.unit_token, self.vault_url]))
def check_ready(self): completed = self._received.get('completed', {}) actual_hash = completed.get(self.instance_id) # My middle name is ready. No, that doesn't sound right. # I eat ready for breakfast. toggle_flag(self.expand_name('ready'), self._requested and actual_hash == self._expected_hash) clear_flag(self.expand_name('changed'))
def change_snapd_refresh(): """Set the system refresh.timer option""" ensure_snapd_min_version("2.31") timer = hookenv.config()["snapd_refresh"] was_set = reactive.is_flag_set("snap.refresh.was-set") if timer or was_set: snap.set_refresh_timer(timer) reactive.toggle_flag("snap.refresh.was-set", timer) reactive.set_flag("snap.refresh.set")
def manage_flags(self): toggle_flag(self.expand_name('{endpoint_name}.connected'), self.is_joined) toggle_flag(self.expand_name('{endpoint_name}.gpu.available'), self.is_joined and self._get_gpu()) requests_data_id = self.expand_name('{endpoint_name}.requests') requests = self.auth_user() if data_changed(requests_data_id, requests): set_flag(self.expand_name('{endpoint_name}.requests.changed'))
def manage_flags(self): """ Set states corresponding to the data we have. """ toggle_flag( self.expand_name('{endpoint_name}.connected'), self.is_joined) toggle_flag( self.expand_name('{endpoint_name}.cohorts.ready'), self.is_joined and self._peers_have_cohorts())
def check_ready(self): """ Manage flags to signal when the endpoint is ready as well as noting if changes have been made since it became ready. """ was_ready = is_flag_set(self.expand_name('ready')) toggle_flag(self.expand_name('ready'), self.is_ready) if self.is_ready and was_ready and self.is_changed: set_flag(self.expand_name('ready.changed')) clear_flag(self.expand_name('changed'))
def manage_flags(self): # we want to make sure all the templates and stuff are written # and pods started before we switch the API server over to # use the webhook. This is critical for the webhook template # since the API server will crash if the file isn't there. toggle_flag(self.expand_name('endpoint.{endpoint_name}.available'), self.is_joined) toggle_flag(self.expand_name('endpoint.{endpoint_name}.ready'), self.is_joined and all(unit.received['webhook_status'] for unit in self.all_joined_units))
def manage_flags(self): any_fields_changed = False for field in ('access_address', 'secret_backend', 'hostname', 'isolated'): flag = self.expand_name('endpoint.{endpoint_name}.' 'changed.{}').format(field) any_fields_changed = any_fields_changed or is_flag_set(flag) clear_flag(flag) toggle_flag(self.expand_name('{endpoint_name}.connected'), self.is_joined) toggle_flag(self.expand_name('endpoint.{endpoint_name}.new-request'), any_fields_changed)
def joined(self): set_flag(self.expand_name('{endpoint_name}.available')) toggle_flag(self.expand_name('{endpoint_name}.certs.requested'), self.new_requests) toggle_flag(self.expand_name('{endpoint_name}.server.certs.requested'), self.new_server_requests) toggle_flag(self.expand_name('{endpoint_name}.client.certs.requested'), self.new_client_requests) # For backwards compatibility, set the old "cert" flags as well toggle_flag(self.expand_name('{endpoint_name}.server.cert.requested'), self.new_server_requests) toggle_flag(self.expand_name('{endpoint_name}.client.cert.requested'), self.new_client_requests)
def check_requests(self): unfulfilled_requests = False for request in self.all_requests: if request.changed: hookenv.log( f'Marking request for processing for {request.unit_name} from {request.instance_id}' ) unfulfilled_requests = True elif not request.is_completed and request.completed_for_instance: request.mark_completed() hookenv.log( f'Marking request as completed for {request.unit_name} from {request.instance_id}' ) toggle_flag(self.expand_name('requested'), unfulfilled_requests) clear_flag(self.expand_name('changed'))
def join_cohort_snapshot(snapname, cohort_key): '''Refresh the snap into the given cohort. If the snap was previously in a cohort, this will update the revision to that of the new cohort snapshot. Note that this does not change the channel that the snap is in, only the revision within that channel. ''' if is_local(snapname): # joining a cohort can override a locally installed snap hookenv.log('Skipping joining cohort for local snap: ' '{}'.format(snapname)) return subprocess.check_output(['snap', 'refresh', snapname, '--cohort', cohort_key]) # even though we just refreshed to the latest in the cohort, it's # slightly possible that there's a newer rev available beyond the cohort reactive.toggle_flag(get_refresh_available_flag(snapname), _check_refresh_available(snapname))
def _fetch(): should_set_status = layer.options.get('docker-resource', 'set-status') queue = unitdata.kv().get('layer.docker-resource.pending', []) failed = [] for res_name in queue: prefix = 'layer.docker-resource.{}'.format(res_name) if should_set_status: layer.status.maintenance('fetching resource: {}'.format(res_name)) try: image_info_filename = hookenv.resource_get(res_name) if not image_info_filename: raise ValueError('no filename returned') image_info = yaml.safe_load(Path(image_info_filename).read_text()) if not image_info: raise ValueError('no data returned') except Exception as e: hookenv.log( 'unable to fetch docker resource {}: {}'.format(res_name, e), level=hookenv.ERROR) failed.append(res_name) set_flag('{}.failed'.format(prefix)) clear_flag('{}.available'.format(prefix)) clear_flag('{}.changed'.format(prefix)) else: unitdata.kv().set('{}.image-info'.format(prefix), image_info) was_available = is_flag_set('{}.available'.format(prefix)) is_changed = data_changed(prefix, image_info) set_flag('{}.available'.format(prefix)) clear_flag('{}.failed'.format(prefix)) toggle_flag('{}.changed'.format(prefix), was_available and is_changed) if failed: if should_set_status: pl = 's' if len(failed) > 1 else '' layer.status.blocked( 'unable to fetch resource{}: {}'.format( pl, ', '.join(failed) ) ) unitdata.kv().set('layer.docker-resource.pending', failed) set_flag('layer.docker-resource.pending') else: unitdata.kv().set('layer.docker-resource.pending', []) clear_flag('layer.docker-resource.pending')
def check_requests(self): toggle_flag(self.expand_name('requests-pending'), len(self.requests) > 0) clear_flag(self.expand_name('changed'))
def manage_flags(self): toggle_flag(self.expand_name('{endpoint_name}.available'), len(self.get_addresses_ports()) > 0)
def manage_flags(self): toggle_flag(self.expand_name('{endpoint_name}.connected'), self.is_joined)
def manage_flags(self): """ Set states corresponding to the data we have. """ toggle_flag(self.expand_name('{endpoint_name}.connected'), self.is_joined) toggle_flag(self.expand_name('{endpoint_name}.dns.available'), self.is_joined and self.dns_ready()) toggle_flag(self.expand_name('{endpoint_name}.auth.available'), self.is_joined and self._has_auth_credentials()) toggle_flag(self.expand_name('{endpoint_name}.cluster_tag.available'), self.is_joined and self.get_cluster_tag()) toggle_flag( self.expand_name('{endpoint_name}.registry_location.available'), self.is_joined and self.get_registry_location()) toggle_flag(self.expand_name('{endpoint_name}.cohort_keys.available'), self.is_joined and self.cohort_keys) toggle_flag(self.expand_name('{endpoint_name}.default_cni.available'), self.is_joined and self.get_default_cni() is not None) toggle_flag( self.expand_name('{endpoint_name}.api_endpoints.available'), self.is_joined and self.get_api_endpoints())
def check_requests(self): requests = self.requests toggle_flag(self.expand_name('requested'), len(requests) > 0) clear_flag(self.expand_name('changed'))
def get_creds(): reactive.toggle_flag('charm.openstack.creds.set', nodepool.get_credentials())
def manage_flags(self): toggle_flag(self.expand_name("{endpoint_name}.connected"), self.is_joined) toggle_flag(self.expand_name("{endpoint_name}.available"), self.config_available()) clear_flag(self.expand_name("endpoint.{endpoint_name}.changed"))
def check_ready(self): toggle_flag(self.expand_name("ready"), self.is_ready) clear_flag(self.expand_name("changed"))
def manage_flags(self): toggle_flag(self.expand_name('endpoint.{endpoint_name}.available'), self.is_joined)
def get_creds(): toggle_flag("charm.azure.creds.set", get_credentials())
def manage_flags(self): super().manage_flags() toggle_flag(self.expand_name('endpoint.{endpoint_name}.failed'), self.is_joined and self.failed_imports)
def get_creds(): toggle_flag('charm.openstack.creds.set', layer.openstack.get_credentials())
def get_creds(): toggle_flag('charm.azure.creds.set', layer.azure.get_credentials())