_id
stringlengths 2
7
| title
stringlengths 1
88
| partition
stringclasses 3
values | text
stringlengths 75
19.8k
| language
stringclasses 1
value | meta_information
dict |
|---|---|---|---|---|---|
q9500
|
BundleCompleter.complete
|
train
|
def complete(
self, config, prompt, session, context, current_arguments, current
):
# type: (CompletionInfo, str, ShellSession, BundleContext, List[str], str) -> List[str]
"""
Returns the list of bundle IDs matching the current state
:param config: Configuration of the current completion
:param prompt: Shell prompt (for re-display)
:param session: Shell session (to display in shell)
:param context: Bundle context of the Shell bundle
:param current_arguments: Current arguments (without the command itself)
:param current: Current word
:return: A list of matches
"""
# Register a method to display helpful completion
self.set_display_hook(self.display_hook, prompt, session, context)
# Return a list of bundle IDs (strings) matching the current value
# and not yet in arguments
rl_matches = []
for bnd in context.get_bundles():
bnd_id = "{0} ".format(bnd.get_bundle_id())
if bnd_id.startswith(current):
rl_matches.append(bnd_id)
return rl_matches
|
python
|
{
"resource": ""
}
|
q9501
|
Container.is_valid
|
train
|
def is_valid(self):
# type: () -> bool
"""
Checks if the component is valid
:return: Always True if it doesn't raise an exception
:raises AssertionError: Invalid properties
"""
assert self._bundle_context
assert self._container_props is not None
assert self._get_distribution_provider()
assert self.get_config_name()
assert self.get_namespace()
return True
|
python
|
{
"resource": ""
}
|
q9502
|
Container._add_export
|
train
|
def _add_export(self, ed_id, inst):
# type: (str, Tuple[Any, EndpointDescription]) -> None
"""
Keeps track of an exported service
:param ed_id: ID of the endpoint description
:param inst: A tuple: (service instance, endpoint description)
"""
with self._exported_instances_lock:
self._exported_services[ed_id] = inst
|
python
|
{
"resource": ""
}
|
q9503
|
Container._find_export
|
train
|
def _find_export(self, func):
# type: (Callable[[Tuple[Any, EndpointDescription]], bool]) -> Optional[Tuple[Any, EndpointDescription]]
"""
Look for an export using the given lookup method
The lookup method must accept a single parameter, which is a tuple
containing a service instance and endpoint description.
:param func: A function to look for the excepted export
:return: The found tuple or None
"""
with self._exported_instances_lock:
for val in self._exported_services.values():
if func(val):
return val
return None
|
python
|
{
"resource": ""
}
|
q9504
|
ExportContainer._export_service
|
train
|
def _export_service(self, svc, ed):
# type: (Any, EndpointDescription) -> None
"""
Registers a service export
:param svc: Service instance
:param ed: Endpoint description
"""
self._add_export(ed.get_id(), (svc, ed))
|
python
|
{
"resource": ""
}
|
q9505
|
ExportContainer.prepare_endpoint_props
|
train
|
def prepare_endpoint_props(self, intfs, svc_ref, export_props):
# type: (List[str], ServiceReference, Dict[str, Any]) -> Dict[str, Any]
"""
Sets up the properties of an endpoint
:param intfs: Specifications to export
:param svc_ref: Reference of the exported service
:param export_props: Export properties
:return: The properties of the endpoint
"""
pkg_vers = rsa.get_package_versions(intfs, export_props)
exported_configs = get_string_plus_property_value(
svc_ref.get_property(SERVICE_EXPORTED_CONFIGS)
)
if not exported_configs:
exported_configs = [self.get_config_name()]
service_intents = set()
svc_intents = export_props.get(SERVICE_INTENTS, None)
if svc_intents:
service_intents.update(svc_intents)
svc_exp_intents = export_props.get(SERVICE_EXPORTED_INTENTS, None)
if svc_exp_intents:
service_intents.update(svc_exp_intents)
svc_exp_intents_extra = export_props.get(
SERVICE_EXPORTED_INTENTS_EXTRA, None
)
if svc_exp_intents_extra:
service_intents.update(svc_exp_intents_extra)
rsa_props = rsa.get_rsa_props(
intfs,
exported_configs,
self._get_supported_intents(),
svc_ref.get_property(SERVICE_ID),
export_props.get(ENDPOINT_FRAMEWORK_UUID),
pkg_vers,
list(service_intents),
)
ecf_props = rsa.get_ecf_props(
self.get_id(),
self.get_namespace(),
rsa.get_next_rsid(),
rsa.get_current_time_millis(),
)
extra_props = rsa.get_extra_props(export_props)
merged = rsa.merge_dicts(rsa_props, ecf_props, extra_props)
# remove service.bundleid
merged.pop(SERVICE_BUNDLE_ID, None)
# remove service.scope
merged.pop(SERVICE_SCOPE, None)
return merged
|
python
|
{
"resource": ""
}
|
q9506
|
ExportContainer.export_service
|
train
|
def export_service(self, svc_ref, export_props):
# type: (ServiceReference, Dict[str, Any]) -> EndpointDescription
"""
Exports the given service
:param svc_ref: Reference to the service to export
:param export_props: Export properties
:return: The endpoint description
"""
ed = EndpointDescription.fromprops(export_props)
self._export_service(
self._get_bundle_context().get_service(svc_ref), ed
)
return ed
|
python
|
{
"resource": ""
}
|
q9507
|
_FactoryCounter.get_service
|
train
|
def get_service(self, factory, svc_registration):
# type: (Any, ServiceRegistration) -> Any
"""
Returns the service required by the bundle. The Service Factory is
called only when necessary while the Prototype Service Factory is
called each time
:param factory: The service factory
:param svc_registration: The ServiceRegistration object
:return: The requested service instance (created if necessary)
"""
svc_ref = svc_registration.get_reference()
if svc_ref.is_prototype():
return self._get_from_prototype(factory, svc_registration)
return self._get_from_factory(factory, svc_registration)
|
python
|
{
"resource": ""
}
|
q9508
|
_FactoryCounter.unget_service
|
train
|
def unget_service(self, factory, svc_registration, service=None):
# type: (Any, ServiceRegistration, Any) -> bool
"""
Releases references to the given service reference
:param factory: The service factory
:param svc_registration: The ServiceRegistration object
:param service: Service instance (for prototype factories)
:return: True if all service references to this service factory
have been released
"""
svc_ref = svc_registration.get_reference()
try:
_, counter = self.__factored[svc_ref]
except KeyError:
logging.warning(
"Trying to release an unknown service factory: %s", svc_ref
)
else:
if svc_ref.is_prototype():
# Notify the factory to clean up this instance
factory.unget_service_instance(
self.__bundle, svc_registration, service
)
if not counter.dec():
# All references have been released: clean up
del self.__factored[svc_ref]
# Call the factory
factory.unget_service(self.__bundle, svc_registration)
# No more reference to this service
return True
# Some references are still there
return False
|
python
|
{
"resource": ""
}
|
q9509
|
_FactoryCounter.cleanup_service
|
train
|
def cleanup_service(self, factory, svc_registration):
# type: (Any, ServiceRegistration) -> bool
"""
If this bundle used that factory, releases the reference; else does
nothing
:param factory: The service factory
:param svc_registration: The ServiceRegistration object
:return: True if the bundle was using the factory, else False
"""
svc_ref = svc_registration.get_reference()
try:
# "service" for factories, "services" for prototypes
services, _ = self.__factored.pop(svc_ref)
except KeyError:
return False
else:
if svc_ref.is_prototype() and services:
for service in services:
try:
factory.unget_service_instance(
self.__bundle, svc_registration, service
)
except Exception:
# Ignore instance-level exceptions, potential errors
# will reappear in unget_service()
pass
# Call the factory
factory.unget_service(self.__bundle, svc_registration)
# No more association
svc_ref.unused_by(self.__bundle)
return True
|
python
|
{
"resource": ""
}
|
q9510
|
ServiceReference.unused_by
|
train
|
def unused_by(self, bundle):
"""
Indicates that this reference is not being used anymore by the given
bundle.
This method should only be used by the framework.
:param bundle: A bundle that used this reference
"""
if bundle is None or bundle is self.__bundle:
# Ignore
return
with self.__usage_lock:
try:
if not self.__using_bundles[bundle].dec():
# This bundle has cleaner all of its usages of this
# reference
del self.__using_bundles[bundle]
except KeyError:
# Ignore error
pass
|
python
|
{
"resource": ""
}
|
q9511
|
ServiceReference.used_by
|
train
|
def used_by(self, bundle):
"""
Indicates that this reference is being used by the given bundle.
This method should only be used by the framework.
:param bundle: A bundle using this reference
"""
if bundle is None or bundle is self.__bundle:
# Ignore
return
with self.__usage_lock:
self.__using_bundles.setdefault(bundle, _UsageCounter()).inc()
|
python
|
{
"resource": ""
}
|
q9512
|
ServiceRegistration.set_properties
|
train
|
def set_properties(self, properties):
"""
Updates the service properties
:param properties: The new properties
:raise TypeError: The argument is not a dictionary
"""
if not isinstance(properties, dict):
raise TypeError("Waiting for dictionary")
# Keys that must not be updated
for forbidden_key in OBJECTCLASS, SERVICE_ID:
try:
del properties[forbidden_key]
except KeyError:
pass
to_delete = []
for key, value in properties.items():
if self.__properties.get(key) == value:
# No update
to_delete.append(key)
for key in to_delete:
# Remove unchanged properties
del properties[key]
if not properties:
# Nothing to do
return
# Ensure that the service has a valid service ranking
try:
properties[SERVICE_RANKING] = int(properties[SERVICE_RANKING])
except (ValueError, TypeError):
# Bad value: ignore update
del properties[SERVICE_RANKING]
except KeyError:
# Service ranking not updated: ignore
pass
# pylint: disable=W0212
with self.__reference._props_lock:
# Update the properties
previous = self.__properties.copy()
self.__properties.update(properties)
if self.__reference.needs_sort_update():
# The sort key and the registry must be updated
self.__update_callback(self.__reference)
# Trigger a new computation in the framework
event = ServiceEvent(
ServiceEvent.MODIFIED, self.__reference, previous
)
self.__framework._dispatcher.fire_service_event(event)
|
python
|
{
"resource": ""
}
|
q9513
|
EventDispatcher.clear
|
train
|
def clear(self):
"""
Clears the event dispatcher
"""
with self.__bnd_lock:
self.__bnd_listeners = []
with self.__svc_lock:
self.__svc_listeners.clear()
with self.__fw_lock:
self.__fw_listeners = []
|
python
|
{
"resource": ""
}
|
q9514
|
EventDispatcher.add_bundle_listener
|
train
|
def add_bundle_listener(self, listener):
"""
Adds a bundle listener
:param listener: The bundle listener to register
:return: True if the listener has been registered, False if it was
already known
:raise BundleException: An invalid listener has been given
"""
if listener is None or not hasattr(listener, "bundle_changed"):
raise BundleException("Invalid bundle listener given")
with self.__bnd_lock:
if listener in self.__bnd_listeners:
self._logger.warning(
"Already known bundle listener '%s'", listener
)
return False
self.__bnd_listeners.append(listener)
return True
|
python
|
{
"resource": ""
}
|
q9515
|
EventDispatcher.add_framework_listener
|
train
|
def add_framework_listener(self, listener):
"""
Registers a listener that will be called back right before the
framework stops.
:param listener: The framework stop listener
:return: True if the listener has been registered, False if it was
already known
:raise BundleException: An invalid listener has been given
"""
if listener is None or not hasattr(listener, "framework_stopping"):
raise BundleException("Invalid framework listener given")
with self.__fw_lock:
if listener in self.__fw_listeners:
self._logger.warning(
"Already known framework listener '%s'", listener
)
return False
self.__fw_listeners.append(listener)
return True
|
python
|
{
"resource": ""
}
|
q9516
|
EventDispatcher.remove_bundle_listener
|
train
|
def remove_bundle_listener(self, listener):
"""
Unregisters a bundle listener
:param listener: The bundle listener to unregister
:return: True if the listener has been unregistered, else False
"""
with self.__bnd_lock:
if listener not in self.__bnd_listeners:
return False
self.__bnd_listeners.remove(listener)
return True
|
python
|
{
"resource": ""
}
|
q9517
|
EventDispatcher.remove_framework_listener
|
train
|
def remove_framework_listener(self, listener):
"""
Unregisters a framework stop listener
:param listener: The framework listener to unregister
:return: True if the listener has been unregistered, else False
"""
with self.__fw_lock:
try:
self.__fw_listeners.remove(listener)
return True
except ValueError:
return False
|
python
|
{
"resource": ""
}
|
q9518
|
EventDispatcher.remove_service_listener
|
train
|
def remove_service_listener(self, listener):
"""
Unregisters a service listener
:param listener: The service listener
:return: True if the listener has been unregistered
"""
with self.__svc_lock:
try:
data = self.__listeners_data.pop(listener)
spec_listeners = self.__svc_listeners[data.specification]
spec_listeners.remove(data)
if not spec_listeners:
del self.__svc_listeners[data.specification]
return True
except KeyError:
return False
|
python
|
{
"resource": ""
}
|
q9519
|
EventDispatcher.fire_bundle_event
|
train
|
def fire_bundle_event(self, event):
"""
Notifies bundle events listeners of a new event in the calling thread.
:param event: The bundle event
"""
with self.__bnd_lock:
# Copy the list of listeners
listeners = self.__bnd_listeners[:]
# Call'em all
for listener in listeners:
try:
listener.bundle_changed(event)
except:
self._logger.exception("Error calling a bundle listener")
|
python
|
{
"resource": ""
}
|
q9520
|
EventDispatcher.fire_framework_stopping
|
train
|
def fire_framework_stopping(self):
"""
Calls all framework listeners, telling them that the framework is
stopping
"""
with self.__fw_lock:
# Copy the list of listeners
listeners = self.__fw_listeners[:]
for listener in listeners:
try:
listener.framework_stopping()
except:
self._logger.exception(
"An error occurred calling one of the "
"framework stop listeners"
)
|
python
|
{
"resource": ""
}
|
q9521
|
EventDispatcher.fire_service_event
|
train
|
def fire_service_event(self, event):
"""
Notifies service events listeners of a new event in the calling thread.
:param event: The service event
"""
# Get the service properties
properties = event.get_service_reference().get_properties()
svc_specs = properties[OBJECTCLASS]
previous = None
endmatch_event = None
svc_modified = event.get_kind() == ServiceEvent.MODIFIED
if svc_modified:
# Modified service event : prepare the end match event
previous = event.get_previous_properties()
endmatch_event = ServiceEvent(
ServiceEvent.MODIFIED_ENDMATCH,
event.get_service_reference(),
previous,
)
with self.__svc_lock:
# Get the listeners for this specification
listeners = set()
for spec in svc_specs:
try:
listeners.update(self.__svc_listeners[spec])
except KeyError:
pass
# Add those which listen to any specification
try:
listeners.update(self.__svc_listeners[None])
except KeyError:
pass
# Filter listeners with EventListenerHooks
listeners = self._filter_with_hooks(event, listeners)
# Get the listeners for this specification
for data in listeners:
# Default event to send : the one we received
sent_event = event
# Test if the service properties matches the filter
ldap_filter = data.ldap_filter
if ldap_filter is not None and not ldap_filter.matches(properties):
# Event doesn't match listener filter...
if (
svc_modified
and previous is not None
and ldap_filter.matches(previous)
):
# ... but previous properties did match
sent_event = endmatch_event
else:
# Didn't match before either, ignore it
continue
# Call'em
try:
data.listener.service_changed(sent_event)
except:
self._logger.exception("Error calling a service listener")
|
python
|
{
"resource": ""
}
|
q9522
|
EventDispatcher._filter_with_hooks
|
train
|
def _filter_with_hooks(self, svc_event, listeners):
"""
Filters listeners with EventListenerHooks
:param svc_event: ServiceEvent being triggered
:param listeners: Listeners to filter
:return: A list of listeners with hook references
"""
svc_ref = svc_event.get_service_reference()
# Get EventListenerHooks service refs from registry
hook_refs = self._registry.find_service_references(
SERVICE_EVENT_LISTENER_HOOK
)
# only do something if there are some hook_refs
if hook_refs:
# Associate bundle context to hooks
ctx_listeners = {}
for listener in listeners:
context = listener.bundle_context
ctx_listeners.setdefault(context, []).append(listener)
# Convert the dictionary to a shrinkable one,
# with shrinkable lists of listeners
shrinkable_ctx_listeners = ShrinkableMap(
{
context: ShrinkableList(value)
for context, value in ctx_listeners.items()
}
)
for hook_ref in hook_refs:
if not svc_ref == hook_ref:
# Get the bundle of the hook service
hook_bundle = hook_ref.get_bundle()
# lookup service from registry
hook_svc = self._registry.get_service(hook_bundle, hook_ref)
if hook_svc is not None:
# call event method of the hook service,
# pass in svc_event and shrinkable_ctx_listeners
# (which can be modified by hook)
try:
hook_svc.event(svc_event, shrinkable_ctx_listeners)
except:
self._logger.exception(
"Error calling EventListenerHook"
)
finally:
# Clean up the service
self._registry.unget_service(hook_bundle, hook_ref)
# Convert the shrinkable_ctx_listeners back to a list of listeners
# before returning
ret_listeners = set()
for bnd_listeners in shrinkable_ctx_listeners.values():
ret_listeners.update(bnd_listeners)
return ret_listeners
# No hook ref
return listeners
|
python
|
{
"resource": ""
}
|
q9523
|
ServiceRegistry.clear
|
train
|
def clear(self):
"""
Clears the registry
"""
with self.__svc_lock:
self.__svc_registry.clear()
self.__svc_factories.clear()
self.__svc_specs.clear()
self.__bundle_svc.clear()
self.__bundle_imports.clear()
self.__factory_usage.clear()
self.__pending_services.clear()
|
python
|
{
"resource": ""
}
|
q9524
|
ServiceRegistry.__sort_registry
|
train
|
def __sort_registry(self, svc_ref):
# type: (ServiceReference) -> None
"""
Sorts the registry, after the update of the sort key of given service
reference
:param svc_ref: A service reference with a modified sort key
"""
with self.__svc_lock:
if svc_ref not in self.__svc_registry:
raise BundleException("Unknown service: {0}".format(svc_ref))
# Remove current references
for spec in svc_ref.get_property(OBJECTCLASS):
# Use bisect to remove the reference (faster)
spec_refs = self.__svc_specs[spec]
idx = bisect.bisect_left(spec_refs, svc_ref)
del spec_refs[idx]
# ... use the new sort key
svc_ref.update_sort_key()
for spec in svc_ref.get_property(OBJECTCLASS):
# ... and insert it again
spec_refs = self.__svc_specs[spec]
bisect.insort_left(spec_refs, svc_ref)
|
python
|
{
"resource": ""
}
|
q9525
|
ServiceRegistry.unregister
|
train
|
def unregister(self, svc_ref):
# type: (ServiceReference) -> Any
"""
Unregisters a service
:param svc_ref: A service reference
:return: The unregistered service instance
:raise BundleException: Unknown service reference
"""
with self.__svc_lock:
try:
# Try in pending services
return self.__pending_services.pop(svc_ref)
except KeyError:
# Not pending: continue
pass
if svc_ref not in self.__svc_registry:
raise BundleException("Unknown service: {0}".format(svc_ref))
# Get the owner
bundle = svc_ref.get_bundle()
# Get the service instance
service = self.__svc_registry.pop(svc_ref)
for spec in svc_ref.get_property(OBJECTCLASS):
spec_services = self.__svc_specs[spec]
# Use bisect to remove the reference (faster)
idx = bisect.bisect_left(spec_services, svc_ref)
del spec_services[idx]
if not spec_services:
del self.__svc_specs[spec]
# Remove the service factory
if svc_ref.is_factory():
# Call unget_service for all client bundle
factory, svc_reg = self.__svc_factories.pop(svc_ref)
for counter in self.__factory_usage.values():
counter.cleanup_service(factory, svc_reg)
else:
# Delete bundle association
bundle_services = self.__bundle_svc[bundle]
bundle_services.remove(svc_ref)
if not bundle_services:
# Don't keep empty lists
del self.__bundle_svc[bundle]
return service
|
python
|
{
"resource": ""
}
|
q9526
|
ServiceRegistry.get_bundle_imported_services
|
train
|
def get_bundle_imported_services(self, bundle):
"""
Returns this bundle's ServiceReference list for all services it is
using or returns None if this bundle is not using any services.
A bundle is considered to be using a service if its use count for that
service is greater than zero.
The list is valid at the time of the call to this method, however, as
the Framework is a very dynamic environment, services can be modified
or unregistered at any time.
:param bundle: The bundle to look into
:return: The references of the services used by this bundle
"""
with self.__svc_lock:
return sorted(self.__bundle_imports.get(bundle, []))
|
python
|
{
"resource": ""
}
|
q9527
|
ServiceRegistry.get_bundle_registered_services
|
train
|
def get_bundle_registered_services(self, bundle):
# type: (Any) -> List[ServiceReference]
"""
Retrieves the services registered by the given bundle. Returns None
if the bundle didn't register any service.
:param bundle: The bundle to look into
:return: The references to the services registered by the bundle
"""
with self.__svc_lock:
return sorted(self.__bundle_svc.get(bundle, []))
|
python
|
{
"resource": ""
}
|
q9528
|
ServiceRegistry.__get_service_from_factory
|
train
|
def __get_service_from_factory(self, bundle, reference):
# type: (Any, ServiceReference) -> Any
"""
Returns a service instance from a service factory or a prototype
service factory
:param bundle: The bundle requiring the service
:param reference: A reference pointing to a factory
:return: The requested service
:raise BundleException: The service could not be found
"""
try:
factory, svc_reg = self.__svc_factories[reference]
# Indicate the dependency
imports = self.__bundle_imports.setdefault(bundle, {})
if reference not in imports:
# New reference usage: store a single usage
# The Factory counter will handle the rest
usage_counter = _UsageCounter()
usage_counter.inc()
imports[reference] = usage_counter
reference.used_by(bundle)
# Check the per-bundle usage counter
factory_counter = self.__factory_usage.setdefault(
bundle, _FactoryCounter(bundle)
)
return factory_counter.get_service(factory, svc_reg)
except KeyError:
# Not found
raise BundleException(
"Service not found (reference: {0})".format(reference)
)
|
python
|
{
"resource": ""
}
|
q9529
|
ServiceRegistry.unget_used_services
|
train
|
def unget_used_services(self, bundle):
"""
Cleans up all service usages of the given bundle.
:param bundle: Bundle to be cleaned up
"""
# Pop used references
try:
imported_refs = list(self.__bundle_imports.pop(bundle))
except KeyError:
# Nothing to do
return
for svc_ref in imported_refs:
# Remove usage marker
svc_ref.unused_by(bundle)
if svc_ref.is_prototype():
# Get factory information and clean up the service from the
# factory counter
factory_counter = self.__factory_usage.pop(bundle)
factory, svc_reg = self.__svc_factories[svc_ref]
factory_counter.cleanup_service(factory, svc_reg)
elif svc_ref.is_factory():
# Factory service, release it the standard way
self.__unget_service_from_factory(bundle, svc_ref)
# Clean up local structures
try:
del self.__factory_usage[bundle]
except KeyError:
pass
try:
self.__bundle_imports.pop(bundle).clear()
except KeyError:
pass
|
python
|
{
"resource": ""
}
|
q9530
|
ServiceRegistry.unget_service
|
train
|
def unget_service(self, bundle, reference, service=None):
# type: (Any, ServiceReference, Any) -> bool
"""
Removes the usage of a service by a bundle
:param bundle: The bundle that used the service
:param reference: A service reference
:param service: Service instance (for Prototype Service Factories)
:return: True if the bundle usage has been removed
"""
with self.__svc_lock:
if reference.is_prototype():
return self.__unget_service_from_factory(
bundle, reference, service
)
elif reference.is_factory():
return self.__unget_service_from_factory(bundle, reference)
try:
# Remove the service reference from the bundle
imports = self.__bundle_imports[bundle]
if not imports[reference].dec():
# No more reference to it
del imports[reference]
except KeyError:
# Unknown reference
return False
else:
# Clean up
if not imports:
del self.__bundle_imports[bundle]
# Update the service reference
reference.unused_by(bundle)
return True
|
python
|
{
"resource": ""
}
|
q9531
|
ServiceRegistry.__unget_service_from_factory
|
train
|
def __unget_service_from_factory(self, bundle, reference, service=None):
# type: (Any, ServiceReference, Any) -> bool
"""
Removes the usage of a a service factory or a prototype
service factory by a bundle
:param bundle: The bundle that used the service
:param reference: A service reference
:param service: Service instance (for prototype factories)
:return: True if the bundle usage has been removed
"""
try:
factory, svc_reg = self.__svc_factories[reference]
except KeyError:
# Unknown service reference
return False
# Check the per-bundle usage counter
try:
counter = self.__factory_usage[bundle]
except KeyError:
# Unknown reference to a factory
return False
else:
if counter.unget_service(factory, svc_reg, service):
try:
# No more dependency
reference.unused_by(bundle)
# All references have been taken away: clean up
if not self.__factory_usage[bundle].is_used():
del self.__factory_usage[bundle]
# Remove the service reference from the bundle
imports = self.__bundle_imports[bundle]
del imports[reference]
except KeyError:
# Unknown reference
return False
else:
# Clean up
if not imports:
del self.__bundle_imports[bundle]
return True
|
python
|
{
"resource": ""
}
|
q9532
|
EDEFReader._convert_value
|
train
|
def _convert_value(vtype, value):
"""
Converts the given value string according to the given type
:param vtype: Type of the value
:param value: String form of the value
:return: The converted value
:raise ValueError: Conversion failed
"""
# Normalize value
value = value.strip()
if vtype == TYPE_STRING:
# Nothing to do
return value
elif vtype in TYPES_INT:
return int(value)
elif vtype in TYPES_FLOAT:
return float(value)
elif vtype in TYPES_BOOLEAN:
# Compare lower-case value
return value.lower() not in ("false", "0")
elif vtype in TYPES_CHAR:
return value[0]
# No luck
raise ValueError("Unknown value type: {0}".format(vtype))
|
python
|
{
"resource": ""
}
|
q9533
|
EDEFWriter._indent
|
train
|
def _indent(self, element, level=0, prefix="\t"):
"""
In-place Element text auto-indent, for pretty printing.
Code from: http://effbot.org/zone/element-lib.htm#prettyprint
:param element: An Element object
:param level: Level of indentation
:param prefix: String to use for each indentation
"""
element_prefix = "\r\n{0}".format(level * prefix)
if len(element):
if not element.text or not element.text.strip():
element.text = element_prefix + prefix
if not element.tail or not element.tail.strip():
element.tail = element_prefix
# Yep, let the "element" variable be overwritten
# pylint: disable=R1704
for element in element:
self._indent(element, level + 1, prefix)
# Tail of the last child
if not element.tail or not element.tail.strip():
element.tail = element_prefix
else:
if level and (not element.tail or not element.tail.strip()):
element.tail = element_prefix
|
python
|
{
"resource": ""
}
|
q9534
|
EDEFWriter._add_container
|
train
|
def _add_container(props_node, tag, container):
"""
Walks through the given container and fills the node
:param props_node: A property node
:param tag: Name of the container tag
:param container: The container
"""
values_node = ElementTree.SubElement(props_node, tag)
for value in container:
value_node = ElementTree.SubElement(values_node, TAG_VALUE)
value_node.text = str(value)
|
python
|
{
"resource": ""
}
|
q9535
|
EDEFWriter._get_type
|
train
|
def _get_type(name, value):
"""
Returns the type associated to the given name or value
:param name: Property name
:param value: Property value
:return: A value type name
"""
# Types forced for known keys
if name in TYPED_BOOL:
return TYPE_BOOLEAN
elif name in TYPED_LONG:
return TYPE_LONG
elif name in TYPED_STRING:
return TYPE_STRING
# We need to analyze the content of value
if isinstance(value, (tuple, list, set)):
# Get the type from container content
try:
# Extract value
value = next(iter(value))
except StopIteration:
# Empty list, can't check
return TYPE_STRING
# Single value
if isinstance(value, int):
# Integer
return TYPE_LONG
elif isinstance(value, float):
# Float
return TYPE_DOUBLE
elif isinstance(value, type(ElementTree.Element(None))):
# XML
return XML_VALUE
# Default: String
return TYPE_STRING
|
python
|
{
"resource": ""
}
|
q9536
|
BasicBot.on_session_start
|
train
|
def on_session_start(self, data):
# pylint: disable=W0613
"""
XMPP session started
"""
# Send initial presence
self.send_presence(ppriority=self._initial_priority)
# Request roster
self.get_roster()
|
python
|
{
"resource": ""
}
|
q9537
|
InviteMixIn.on_invite
|
train
|
def on_invite(self, data):
"""
Multi-User Chat invite
"""
if not self._nick:
self._nick = self.boundjid.user
# Join the room
self.plugin["xep_0045"].joinMUC(data["from"], self._nick)
|
python
|
{
"resource": ""
}
|
q9538
|
ServiceDiscoveryMixin.iter_services
|
train
|
def iter_services(self, feature=None):
"""
Iterates over the root-level services on the server which provides the
requested feature
:param feature: Feature that the service must provide (optional)
:return: A generator of services JID
"""
# Get the list of root services
items = self["xep_0030"].get_items(
jid=self.boundjid.domain,
ifrom=self.boundjid.full,
block=True,
timeout=10,
)
for item in items["disco_items"]["items"]:
# Each item is a 3-tuple. The service JID is the first entry
if not feature:
# No filter
yield item[0]
else:
# Get service details
info = self["xep_0030"].get_info(
jid=item[0],
ifrom=self.boundjid.full,
block=True,
timeout=10,
)
if feature in info["disco_info"]["features"]:
# The service provides the required feature
yield item[0]
|
python
|
{
"resource": ""
}
|
q9539
|
_find_assignment
|
train
|
def _find_assignment(arg_token):
"""
Find the first non-escaped assignment in the given argument token.
Returns -1 if no assignment was found.
:param arg_token: The argument token
:return: The index of the first assignment, or -1
"""
idx = arg_token.find("=")
while idx != -1:
if idx != 0 and arg_token[idx - 1] != "\\":
# No escape character
return idx
idx = arg_token.find("=", idx + 1)
# No assignment found
return -1
|
python
|
{
"resource": ""
}
|
q9540
|
_split_ns_command
|
train
|
def _split_ns_command(cmd_token):
"""
Extracts the name space and the command name of the given command token.
:param cmd_token: The command token
:return: The extracted (name space, command) tuple
"""
namespace = None
cmd_split = cmd_token.split(".", 1)
if len(cmd_split) == 1:
# No name space given
command = cmd_split[0]
else:
# Got a name space and a command
namespace = cmd_split[0]
command = cmd_split[1]
if not namespace:
# No name space given: given an empty one
namespace = ""
# Use lower case values only
return namespace.lower(), command.lower()
|
python
|
{
"resource": ""
}
|
q9541
|
Shell.register_command
|
train
|
def register_command(self, namespace, command, method):
"""
Registers the given command to the shell.
The namespace can be None, empty or "default"
:param namespace: The command name space.
:param command: The shell name of the command
:param method: The method to call
:return: True if the method has been registered, False if it was
already known or invalid
"""
if method is None:
self._logger.error("No method given for %s.%s", namespace, command)
return False
# Store everything in lower case
namespace = (namespace or "").strip().lower()
command = (command or "").strip().lower()
if not namespace:
namespace = DEFAULT_NAMESPACE
if not command:
self._logger.error("No command name given")
return False
if namespace not in self._commands:
space = self._commands[namespace] = {}
else:
space = self._commands[namespace]
if command in space:
self._logger.error(
"Command already registered: %s.%s", namespace, command
)
return False
space[command] = method
return True
|
python
|
{
"resource": ""
}
|
q9542
|
Shell.get_command_completers
|
train
|
def get_command_completers(self, namespace, command):
# type: (str, str) -> CompletionInfo
"""
Returns the completer method associated to the given command, or None
:param namespace: The command name space.
:param command: The shell name of the command
:return: A CompletionConfiguration object
:raise KeyError: Unknown command or name space
"""
# Find the method (can raise a KeyError)
method = self._commands[namespace][command]
# Return the completer, if any
return getattr(method, ATTR_COMPLETERS, None)
|
python
|
{
"resource": ""
}
|
q9543
|
Shell.unregister
|
train
|
def unregister(self, namespace, command=None):
"""
Unregisters the given command. If command is None, the whole name space
is unregistered.
:param namespace: The command name space.
:param command: The shell name of the command, or None
:return: True if the command was known, else False
"""
if not namespace:
namespace = DEFAULT_NAMESPACE
namespace = namespace.strip().lower()
if namespace not in self._commands:
self._logger.warning("Unknown name space: %s", namespace)
return False
if command is not None:
# Remove the command
command = command.strip().lower()
if command not in self._commands[namespace]:
self._logger.warning(
"Unknown command: %s.%s", namespace, command
)
return False
del self._commands[namespace][command]
# Remove the name space if necessary
if not self._commands[namespace]:
del self._commands[namespace]
else:
# Remove the whole name space
del self._commands[namespace]
return True
|
python
|
{
"resource": ""
}
|
q9544
|
Shell.__find_command_ns
|
train
|
def __find_command_ns(self, command):
"""
Returns the name spaces where the given command named is registered.
If the command exists in the default name space, the returned list will
only contain the default name space.
Returns an empty list of the command is unknown
:param command: A command name
:return: A list of name spaces
"""
# Look for the spaces where the command name appears
namespaces = []
for namespace, commands in self._commands.items():
if command in commands:
namespaces.append(namespace)
# Sort name spaces
namespaces.sort()
# Default name space must always come first
try:
namespaces.remove(DEFAULT_NAMESPACE)
namespaces.insert(0, DEFAULT_NAMESPACE)
except ValueError:
# Default name space wasn't present
pass
return namespaces
|
python
|
{
"resource": ""
}
|
q9545
|
Shell.get_ns_commands
|
train
|
def get_ns_commands(self, cmd_name):
"""
Retrieves the possible name spaces and commands associated to the given
command name.
:param cmd_name: The given command name
:return: A list of 2-tuples (name space, command)
:raise ValueError: Unknown command name
"""
namespace, command = _split_ns_command(cmd_name)
if not namespace:
# Name space not given, look for the commands
spaces = self.__find_command_ns(command)
if not spaces:
# Unknown command
raise ValueError("Unknown command {0}".format(command))
else:
# Return a sorted list of tuples
return sorted((namespace, command) for namespace in spaces)
# Single match
return [(namespace, command)]
|
python
|
{
"resource": ""
}
|
q9546
|
Shell.get_ns_command
|
train
|
def get_ns_command(self, cmd_name):
"""
Retrieves the name space and the command associated to the given
command name.
:param cmd_name: The given command name
:return: A 2-tuple (name space, command)
:raise ValueError: Unknown command name
"""
namespace, command = _split_ns_command(cmd_name)
if not namespace:
# Name space not given, look for the command
spaces = self.__find_command_ns(command)
if not spaces:
# Unknown command
raise ValueError("Unknown command {0}".format(command))
elif len(spaces) > 1:
# Multiple possibilities
if spaces[0] == DEFAULT_NAMESPACE:
# Default name space has priority
namespace = DEFAULT_NAMESPACE
else:
# Ambiguous name
raise ValueError(
"Multiple name spaces for command '{0}': {1}".format(
command, ", ".join(sorted(spaces))
)
)
else:
# Use the found name space
namespace = spaces[0]
# Command found
return namespace, command
|
python
|
{
"resource": ""
}
|
q9547
|
Shell.execute
|
train
|
def execute(self, cmdline, session=None):
"""
Executes the command corresponding to the given line
:param cmdline: Command line to parse
:param session: Current shell session
:return: True if command succeeded, else False
"""
if session is None:
# Default session
session = beans.ShellSession(
beans.IOHandler(sys.stdin, sys.stdout), {}
)
assert isinstance(session, beans.ShellSession)
# Split the command line
if not cmdline:
return False
# Convert the line into a string
cmdline = to_str(cmdline)
try:
line_split = shlex.split(cmdline, True, True)
except ValueError as ex:
session.write_line("Error reading line: {0}", ex)
return False
if not line_split:
return False
try:
# Extract command information
namespace, command = self.get_ns_command(line_split[0])
except ValueError as ex:
# Unknown command
session.write_line(str(ex))
return False
# Get the content of the name space
space = self._commands.get(namespace, None)
if not space:
session.write_line("Unknown name space {0}", namespace)
return False
# Get the method object
method = space.get(command, None)
if method is None:
session.write_line("Unknown command: {0}.{1}", namespace, command)
return False
# Make arguments and keyword arguments
args, kwargs = _make_args(
line_split[1:], session, self._framework.get_properties()
)
try:
# Execute it
result = method(session, *args, **kwargs)
# Store the result as $?
if result is not None:
session.set(beans.RESULT_VAR_NAME, result)
# 0, None are considered as success, so don't use not nor bool
return result is not False
except TypeError as ex:
# Invalid arguments...
self._logger.error(
"Error calling %s.%s: %s", namespace, command, ex
)
session.write_line("Invalid method call: {0}", ex)
self.__print_namespace_help(session, namespace, command)
return False
except Exception as ex:
# Error
self._logger.exception(
"Error calling %s.%s: %s", namespace, command, ex
)
session.write_line("{0}: {1}", type(ex).__name__, str(ex))
return False
finally:
# Try to flush in any case
try:
session.flush()
except IOError:
pass
|
python
|
{
"resource": ""
}
|
q9548
|
Shell.__extract_help
|
train
|
def __extract_help(method):
"""
Formats the help string for the given method
:param method: The method to document
:return: A tuple: (arguments list, documentation line)
"""
if method is None:
return "(No associated method)"
# Get the arguments
arg_spec = get_method_arguments(method)
# Ignore the session argument
start_arg = 1
# Compute the number of arguments with default value
if arg_spec.defaults is not None:
nb_optional = len(arg_spec.defaults)
# Let the mandatory arguments as they are
args = [
"<{0}>".format(arg)
for arg in arg_spec.args[start_arg:-nb_optional]
]
# Add the other arguments
for name, value in zip(
arg_spec.args[-nb_optional:], arg_spec.defaults[-nb_optional:]
):
if value is not None:
args.append("[<{0}>={1}]".format(name, value))
else:
args.append("[<{0}>]".format(name))
else:
# All arguments are mandatory
args = ["<{0}>".format(arg) for arg in arg_spec.args[start_arg:]]
# Extra arguments
if arg_spec.keywords:
args.append("[<property=value> ...]")
if arg_spec.varargs:
args.append("[<{0} ...>]".format(arg_spec.varargs))
# Get the documentation string
doc = inspect.getdoc(method) or "(Documentation missing)"
return " ".join(args), " ".join(doc.split())
|
python
|
{
"resource": ""
}
|
q9549
|
Shell.__print_command_help
|
train
|
def __print_command_help(self, session, namespace, cmd_name):
"""
Prints the documentation of the given command
:param session: Session handler
:param namespace: Name space of the command
:param cmd_name: Name of the command
"""
# Extract documentation
args, doc = self.__extract_help(self._commands[namespace][cmd_name])
# Print the command name, and its arguments
if args:
session.write_line("- {0} {1}", cmd_name, args)
else:
session.write_line("- {0}", cmd_name)
# Print the documentation line
session.write_line("\t\t{0}", doc)
|
python
|
{
"resource": ""
}
|
q9550
|
Shell.__print_namespace_help
|
train
|
def __print_namespace_help(self, session, namespace, cmd_name=None):
"""
Prints the documentation of all the commands in the given name space,
or only of the given command
:param session: Session Handler
:param namespace: Name space of the command
:param cmd_name: Name of the command to show, None to show them all
"""
session.write_line("=== Name space '{0}' ===", namespace)
# Get all commands in this name space
if cmd_name is None:
names = [command for command in self._commands[namespace]]
names.sort()
else:
names = [cmd_name]
first_cmd = True
for command in names:
if not first_cmd:
# Print an empty line
session.write_line("\n")
self.__print_command_help(session, namespace, command)
first_cmd = False
|
python
|
{
"resource": ""
}
|
q9551
|
Shell.print_help
|
train
|
def print_help(self, session, command=None):
"""
Prints the available methods and their documentation, or the
documentation of the given command.
"""
if command:
# Single command mode
if command in self._commands:
# Argument is a name space
self.__print_namespace_help(session, command)
was_namespace = True
else:
was_namespace = False
# Also print the name of matching commands
try:
# Extract command name space and name
possibilities = self.get_ns_commands(command)
except ValueError as ex:
# Unknown command
if not was_namespace:
# ... and no name space were matching either -> error
session.write_line(str(ex))
return False
else:
# Print the help of the found command
if was_namespace:
# Give some space
session.write_line("\n\n")
for namespace, cmd_name in possibilities:
self.__print_namespace_help(session, namespace, cmd_name)
else:
# Get all name spaces
namespaces = list(self._commands.keys())
namespaces.remove(DEFAULT_NAMESPACE)
namespaces.sort()
namespaces.insert(0, DEFAULT_NAMESPACE)
first_ns = True
for namespace in namespaces:
if not first_ns:
# Add empty lines
session.write_line("\n\n")
# Print the help of all commands
self.__print_namespace_help(session, namespace)
first_ns = False
return None
|
python
|
{
"resource": ""
}
|
q9552
|
Shell.var_unset
|
train
|
def var_unset(session, name):
"""
Unsets the given variable
"""
name = name.strip()
try:
session.unset(name)
except KeyError:
session.write_line("Unknown variable: {0}", name)
return False
else:
session.write_line("Variable {0} unset.", name)
return None
|
python
|
{
"resource": ""
}
|
q9553
|
_Configuration.add_properties
|
train
|
def add_properties(self, properties):
"""
Updates the framework properties dictionary
:param properties: New framework properties to add
"""
if isinstance(properties, dict):
self._properties.update(properties)
|
python
|
{
"resource": ""
}
|
q9554
|
_Configuration.add_environment
|
train
|
def add_environment(self, environ):
"""
Updates the environment dictionary with the given one.
Existing entries are overridden by the given ones
:param environ: New environment variables
"""
if isinstance(environ, dict):
self._environment.update(environ)
|
python
|
{
"resource": ""
}
|
q9555
|
_Configuration.add_paths
|
train
|
def add_paths(self, paths):
"""
Adds entries to the Python path.
The given paths are normalized before being added to the left of the
list
:param paths: New paths to add
"""
if paths:
# Use new paths in priority
self._paths = list(paths) + self._paths
|
python
|
{
"resource": ""
}
|
q9556
|
_Configuration.add_components
|
train
|
def add_components(self, components):
"""
Adds a list of components to instantiate
:param components: The description of components
:raise KeyError: Missing component configuration
"""
if components:
for component in components:
self._components[component["name"]] = (
component["factory"],
component.get("properties", {}),
)
|
python
|
{
"resource": ""
}
|
q9557
|
_Configuration.normalize
|
train
|
def normalize(self):
"""
Normalizes environment variables, paths and filters the lists of
bundles to install and start.
After this call, the environment variables of this process will have
been updated.
"""
# Add environment variables
os.environ.update(self._environment)
# Normalize paths and avoid duplicates
self._paths = remove_duplicates(
os.path.realpath(os.path.expanduser(os.path.expandvars(path)))
for path in self._paths
if os.path.exists(path)
)
# Normalize the lists of bundles
self._bundles = remove_duplicates(self._bundles)
|
python
|
{
"resource": ""
}
|
q9558
|
InitFileHandler.find_default
|
train
|
def find_default(self, filename):
"""
A generate which looks in common folders for the default configuration
file. The paths goes from system defaults to user specific files.
:param filename: The name of the file to find
:return: The complete path to the found files
"""
for path in self.DEFAULT_PATH:
# Normalize path
path = os.path.expanduser(os.path.expandvars(path))
fullname = os.path.realpath(os.path.join(path, filename))
if os.path.exists(fullname) and os.path.isfile(fullname):
yield fullname
|
python
|
{
"resource": ""
}
|
q9559
|
InitFileHandler.load
|
train
|
def load(self, filename=None):
"""
Loads the given file and adds its content to the current state.
This method can be called multiple times to merge different files.
If no filename is given, this method loads all default files found.
It returns False if no default configuration file has been found
:param filename: The file to load
:return: True if the file has been correctly parsed, False if no file
was given and no default file exist
:raise IOError: Error loading file
"""
if not filename:
for name in self.find_default(".pelix.conf"):
self.load(name)
else:
with open(filename, "r") as filep:
self.__parse(json.load(filep))
|
python
|
{
"resource": ""
}
|
q9560
|
InitFileHandler.__parse
|
train
|
def __parse(self, configuration):
"""
Parses the given configuration dictionary
:param configuration: A configuration as a dictionary (JSON object)
"""
for entry in (
"properties",
"environment",
"paths",
"bundles",
"components",
):
# Check if current values must be reset
reset_key = "reset_{0}".format(entry)
# Compute the name of the method
call_name = "add" if not configuration.get(reset_key) else "set"
method = getattr(self.__state, "{0}_{1}".format(call_name, entry))
# Update configuration
method(configuration.get(entry))
|
python
|
{
"resource": ""
}
|
q9561
|
InitFileHandler.normalize
|
train
|
def normalize(self):
"""
Normalizes environment variables and the Python path.
This method first updates the environment variables (``os.environ``).
Then, it normalizes the Python path (``sys.path``) by resolving all
references to the user directory and environment variables.
"""
# Normalize configuration
self.__state.normalize()
# Update sys.path, avoiding duplicates
whole_path = list(self.__state.paths)
whole_path.extend(sys.path)
# Ensure the working directory as first search path
sys.path = ["."]
for path in whole_path:
if path not in sys.path:
sys.path.append(path)
|
python
|
{
"resource": ""
}
|
q9562
|
InitFileHandler.instantiate_components
|
train
|
def instantiate_components(self, context):
"""
Instantiate the defined components
.. note::
This method requires the iPOPO core service to be registered.
This means that the ``pelix.ipopo.core`` must have been declared in
the list of bundles (or installed and started programmatically).
:param context: A :class:`~pelix.framework.BundleContext` object
:raise BundleException: Error looking for the iPOPO service or
starting a component
"""
with use_ipopo(context) as ipopo:
for name, (factory, properties) in self.__state.components.items():
ipopo.instantiate(factory, name, properties)
|
python
|
{
"resource": ""
}
|
q9563
|
literalize_string
|
train
|
def literalize_string(content, is_unicode=False):
r'''Literalize a string content.
Examples:
>>> print literalize_string('str')
'str'
>>> print literalize_string('\'str\'')
"'str'"
>>> print literalize_string('\"\'str\'\"')
'"\'str\'"'
'''
quote_mark = "'"
if "'" in content:
quote_mark = '"'
if '"' in content:
quote_mark = "'"
content = content.replace(r"'", r"\'")
if '\n' in content:
quote_mark *= 3
return 'u'[not is_unicode:]+quote_mark+content+quote_mark
|
python
|
{
"resource": ""
}
|
q9564
|
unescape_string_literal
|
train
|
def unescape_string_literal(literal, encoding):
r'''Unescape a string or unicode literal.
Examples:
>>> u = u'\u4e16\u754c\u4f60\u597d' # 世界你好
>>> print unescape_string_literal(repr(u), 'utf-8')
u'世界你好'
>>> print unescape_string_literal(repr(u.encode('utf-8')), 'utf-8')
'世界你好'
>>> print unescape_string_literal(repr(u.encode('big5')), 'utf-8')
'\xa5@\xac\xc9\xa7A\xa6n'
'''
if encoding is None:
encoding = getfilesystemencoding()
if literal[0] in 'uU':
return literalize_string(
literal[2:-1].decode('unicode-escape').encode(encoding),
is_unicode=True
)
else:
content = literal[1:-1].decode('string-escape')
# keep it escaped if the encoding doesn't work on it
try:
content.decode(encoding)
except UnicodeDecodeError:
return literal
return literalize_string(content)
|
python
|
{
"resource": ""
}
|
q9565
|
unescape
|
train
|
def unescape(b, encoding):
'''Unescape all string and unicode literals in bytes.'''
return string_literal_re.sub(
lambda m: unescape_string_literal(m.group(), encoding),
b
)
|
python
|
{
"resource": ""
}
|
q9566
|
make_unistream
|
train
|
def make_unistream(stream):
'''Make a stream which unescapes string literals before writes out.'''
unistream = lambda: 'I am an unistream!'
# make unistream look like the stream
for attr_name in dir(stream):
if not attr_name.startswith('_'):
setattr(unistream, attr_name, getattr(stream, attr_name))
# modify the write method to unescape the output
unistream.write = lambda b: stream.write(
# TODO: the to_bytes makes the behavior different, should we care?
unescape(to_bytes(b, unistream.encoding), unistream.encoding)
)
return unistream
|
python
|
{
"resource": ""
}
|
q9567
|
format_frame_info
|
train
|
def format_frame_info(frame):
"""
Formats the given stack frame to show its position in the code and
part of its context
:param frame: A stack frame
"""
# Same as in traceback.extract_stack
line_no = frame.f_lineno
code = frame.f_code
filename = code.co_filename
method_name = code.co_name
linecache.checkcache(filename)
try:
# Try to get the type of the calling object
instance = frame.f_locals["self"]
method_name = "{0}::{1}".format(type(instance).__name__, method_name)
except KeyError:
# Not called from a bound method
pass
# File & line
output_lines = [
' File "{0}", line {1}, in {2}'.format(filename, line_no, method_name)
]
# Arguments
if frame.f_locals:
# Pypy keeps f_locals as an empty dictionary
arg_info = inspect.getargvalues(frame)
for name in arg_info.args:
try:
output_lines.append(
" - {0:s} = {1}".format(name, repr(frame.f_locals[name]))
)
except TypeError:
# Happens in dict/list-comprehensions in Python 2.x
name = name[0]
output_lines.append(
" - {0:s} = {1}".format(name, repr(frame.f_locals[name]))
)
if arg_info.varargs:
output_lines.append(
" - *{0:s} = {1}".format(
arg_info.varargs, frame.f_locals[arg_info.varargs]
)
)
if arg_info.keywords:
output_lines.append(
" - **{0:s} = {1}".format(
arg_info.keywords, frame.f_locals[arg_info.keywords]
)
)
# Line block
lines = _extract_lines(filename, frame.f_globals, line_no, 3)
if lines:
output_lines.append("")
prefix = " "
output_lines.append(
"{0}{1}".format(prefix, "\n{0}".format(prefix).join(lines))
)
return "\n".join(output_lines)
|
python
|
{
"resource": ""
}
|
q9568
|
_extract_lines
|
train
|
def _extract_lines(filename, f_globals, line_no, around):
"""
Extracts a block of lines from the given file
:param filename: Name of the source file
:param f_globals: Globals of the frame of the current code
:param line_no: Current line of code
:param around: Number of line to print before and after the current one
"""
current_line = linecache.getline(filename, line_no, f_globals)
if not current_line:
# No data on this line
return ""
lines = []
# Add some lines before
for pre_line_no in range(line_no - around, line_no):
pre_line = linecache.getline(filename, pre_line_no, f_globals)
lines.append("{0}".format(pre_line.rstrip()))
# The line itself
lines.append("{0}".format(current_line.rstrip()))
# Add some lines after
for pre_line_no in range(line_no + 1, line_no + around + 1):
pre_line = linecache.getline(filename, pre_line_no, f_globals)
lines.append("{0}".format(pre_line.rstrip()))
# Smart left strip
minimal_tab = None
for line in lines:
if line.strip():
tab = len(line) - len(line.lstrip())
if minimal_tab is None or tab < minimal_tab:
minimal_tab = tab
if minimal_tab > 0:
lines = [line[minimal_tab:] for line in lines]
# Add some place for a marker
marked_line = ">> {0}".format(lines[around])
lines = [" {0}".format(line) for line in lines]
lines[around] = marked_line
lines.append("")
return lines
|
python
|
{
"resource": ""
}
|
q9569
|
_ReportCommands.get_level_methods
|
train
|
def get_level_methods(self, level):
"""
Returns the methods to call for the given level of report
:param level: The level of report
:return: The set of methods to call to fill the report
:raise KeyError: Unknown level or alias
"""
try:
# Real name of the level
return set(self.__levels[level])
except KeyError:
# Alias
result = set()
for sub_level in self.__aliases[level]:
result.update(self.get_level_methods(sub_level))
return result
|
python
|
{
"resource": ""
}
|
q9570
|
_ReportCommands.print_levels
|
train
|
def print_levels(self, session):
"""
Lists available levels
"""
lines = []
for level in sorted(self.get_levels()):
methods = sorted(
method.__name__ for method in self.get_level_methods(level)
)
lines.append("- {0}:".format(level))
lines.append("\t{0}".format(", ".join(methods)))
session.write_line("\n".join(lines))
|
python
|
{
"resource": ""
}
|
q9571
|
_ReportCommands.os_details
|
train
|
def os_details():
"""
Returns a dictionary containing details about the operating system
"""
# Compute architecture and linkage
bits, linkage = platform.architecture()
results = {
# Machine details
"platform.arch.bits": bits,
"platform.arch.linkage": linkage,
"platform.machine": platform.machine(),
"platform.process": platform.processor(),
"sys.byteorder": sys.byteorder,
# OS details
"os.name": os.name,
"host.name": socket.gethostname(),
"sys.platform": sys.platform,
"platform.system": platform.system(),
"platform.release": platform.release(),
"platform.version": platform.version(),
"encoding.filesystem": sys.getfilesystemencoding(),
}
# Paths and line separators
for name in "sep", "altsep", "pathsep", "linesep":
results["os.{0}".format(name)] = getattr(os, name, None)
try:
# Available since Python 3.4
results["os.cpu_count"] = os.cpu_count()
except AttributeError:
results["os.cpu_count"] = None
try:
# Only for Unix
# pylint: disable=E1101
results["sys.dlopenflags"] = sys.getdlopenflags()
except AttributeError:
results["sys.dlopenflags"] = None
return results
|
python
|
{
"resource": ""
}
|
q9572
|
_ReportCommands.process_details
|
train
|
def process_details():
"""
Returns details about the current process
"""
results = {"argv": sys.argv, "working.directory": os.getcwd()}
# Process ID and execution IDs (UID, GID, Login, ...)
for key, method in {
"pid": "getpid",
"ppid": "getppid",
"login": "getlogin",
"uid": "getuid",
"euid": "geteuid",
"gid": "getgid",
"egid": "getegid",
"groups": "getgroups",
}.items():
try:
results[key] = getattr(os, method)()
except (AttributeError, OSError):
results[key] = None
return results
|
python
|
{
"resource": ""
}
|
q9573
|
_ReportCommands.network_details
|
train
|
def network_details():
"""
Returns details about the network links
"""
# Get IPv4 details
ipv4_addresses = [
info[4][0]
for info in socket.getaddrinfo(
socket.gethostname(), None, socket.AF_INET
)
]
# Add localhost
ipv4_addresses.extend(
info[4][0]
for info in socket.getaddrinfo("localhost", None, socket.AF_INET)
)
# Filter addresses
ipv4_addresses = sorted(set(ipv4_addresses))
try:
# Get IPv6 details
ipv6_addresses = [
info[4][0]
for info in socket.getaddrinfo(
socket.gethostname(), None, socket.AF_INET6
)
]
# Add localhost
ipv6_addresses.extend(
info[4][0]
for info in socket.getaddrinfo(
"localhost", None, socket.AF_INET6
)
)
# Filter addresses
ipv6_addresses = sorted(set(ipv6_addresses))
except (socket.gaierror, AttributeError):
# AttributeError: AF_INET6 is missing in some versions of Python
ipv6_addresses = None
return {
"IPv4": ipv4_addresses,
"IPv6": ipv6_addresses,
"host.name": socket.gethostname(),
"host.fqdn": socket.getfqdn(),
}
|
python
|
{
"resource": ""
}
|
q9574
|
_ReportCommands.python_details
|
train
|
def python_details():
"""
Returns a dictionary containing details about the Python interpreter
"""
build_no, build_date = platform.python_build()
results = {
# Version of interpreter
"build.number": build_no,
"build.date": build_date,
"compiler": platform.python_compiler(),
"branch": platform.python_branch(),
"revision": platform.python_revision(),
"implementation": platform.python_implementation(),
"version": ".".join(str(v) for v in sys.version_info),
# API version
"api.version": sys.api_version,
# Installation details
"prefix": sys.prefix,
"base_prefix": getattr(sys, "base_prefix", None),
"exec_prefix": sys.exec_prefix,
"base_exec_prefix": getattr(sys, "base_exec_prefix", None),
# Execution details
"executable": sys.executable,
"encoding.default": sys.getdefaultencoding(),
# Other details, ...
"recursion_limit": sys.getrecursionlimit(),
}
# Threads implementation details
thread_info = getattr(sys, "thread_info", (None, None, None))
results["thread_info.name"] = thread_info[0]
results["thread_info.lock"] = thread_info[1]
results["thread_info.version"] = thread_info[2]
# ABI flags (POSIX only)
results["abiflags"] = getattr(sys, "abiflags", None)
# -X options (CPython only)
results["x_options"] = getattr(sys, "_xoptions", None)
return results
|
python
|
{
"resource": ""
}
|
q9575
|
_ReportCommands.python_modules
|
train
|
def python_modules():
"""
Returns the list of Python modules and their file
"""
imported = {}
results = {"builtins": sys.builtin_module_names, "imported": imported}
for module_name, module_ in sys.modules.items():
if module_name not in sys.builtin_module_names:
try:
imported[module_name] = inspect.getfile(module_)
except TypeError:
imported[
module_name
] = "<no file information :: {0}>".format(repr(module_))
return results
|
python
|
{
"resource": ""
}
|
q9576
|
_ReportCommands.pelix_infos
|
train
|
def pelix_infos(self):
"""
Basic information about the Pelix framework instance
"""
framework = self.__context.get_framework()
return {
"version": framework.get_version(),
"properties": framework.get_properties(),
}
|
python
|
{
"resource": ""
}
|
q9577
|
_ReportCommands.pelix_bundles
|
train
|
def pelix_bundles(self):
"""
List of installed bundles
"""
framework = self.__context.get_framework()
return {
bundle.get_bundle_id(): {
"name": bundle.get_symbolic_name(),
"version": bundle.get_version(),
"state": bundle.get_state(),
"location": bundle.get_location(),
}
for bundle in framework.get_bundles()
}
|
python
|
{
"resource": ""
}
|
q9578
|
_ReportCommands.pelix_services
|
train
|
def pelix_services(self):
"""
List of registered services
"""
return {
svc_ref.get_property(pelix.constants.SERVICE_ID): {
"specifications": svc_ref.get_property(
pelix.constants.OBJECTCLASS
),
"ranking": svc_ref.get_property(
pelix.constants.SERVICE_RANKING
),
"properties": svc_ref.get_properties(),
"bundle.id": svc_ref.get_bundle().get_bundle_id(),
"bundle.name": svc_ref.get_bundle().get_symbolic_name(),
}
for svc_ref in self.__context.get_all_service_references(None)
}
|
python
|
{
"resource": ""
}
|
q9579
|
_ReportCommands.ipopo_factories
|
train
|
def ipopo_factories(self):
"""
List of iPOPO factories
"""
try:
with use_ipopo(self.__context) as ipopo:
return {
name: ipopo.get_factory_details(name)
for name in ipopo.get_factories()
}
except BundleException:
# iPOPO is not available:
return None
|
python
|
{
"resource": ""
}
|
q9580
|
_ReportCommands.ipopo_instances
|
train
|
def ipopo_instances(self):
"""
List of iPOPO instances
"""
try:
with use_ipopo(self.__context) as ipopo:
return {
instance[0]: ipopo.get_instance_details(instance[0])
for instance in ipopo.get_instances()
}
except BundleException:
# iPOPO is not available:
return None
|
python
|
{
"resource": ""
}
|
q9581
|
_ReportCommands.to_json
|
train
|
def to_json(self, data):
"""
Converts the given object to a pretty-formatted JSON string
:param data: the object to convert to JSON
:return: A pretty-formatted JSON string
"""
# Don't forget the empty line at the end of the file
return (
json.dumps(
data,
sort_keys=True,
indent=4,
separators=(",", ": "),
default=self.json_converter,
)
+ "\n"
)
|
python
|
{
"resource": ""
}
|
q9582
|
_ReportCommands.show_report
|
train
|
def show_report(self, session, *levels):
"""
Shows the report that has been generated
"""
if levels:
self.make_report(session, *levels)
if self.__report:
session.write_line(self.to_json(self.__report))
else:
session.write_line("No report to show")
|
python
|
{
"resource": ""
}
|
q9583
|
_ReportCommands.write_report
|
train
|
def write_report(self, session, filename):
"""
Writes the report in JSON format to the given file
"""
if not self.__report:
session.write_line("No report to write down")
return
try:
with open(filename, "w+") as out_file:
out_file.write(self.to_json(self.__report))
except IOError as ex:
session.write_line("Error writing to file: {0}", ex)
|
python
|
{
"resource": ""
}
|
q9584
|
_MqttCallableProxy.handle_result
|
train
|
def handle_result(self, result, error):
"""
The result has been received
:param result: Call result
:param error: Error message
"""
if not self._error and not self._result:
# Store results, if not already set
self._error = error
self._result = result
# Unlock the call
self._event.set()
|
python
|
{
"resource": ""
}
|
q9585
|
main
|
train
|
def main():
"""
Starts a Pelix framework and waits for it to stop
"""
# Prepare the framework, with iPOPO and the shell console
# Warning: we only use the first argument of this method, a list of bundles
framework = pelix.framework.create_framework((
# iPOPO
"pelix.ipopo.core",
# Shell core (engine)
"pelix.shell.core",
# Text console
"pelix.shell.console"))
# Start the framework, and the pre-installed bundles
framework.start()
# Get the bundle context of the framework, i.e. the link between the
# framework starter and its content.
context = framework.get_bundle_context()
# Start the spell dictionary bundles, which provide the dictionary services
context.install_bundle("spell_dictionary_EN").start()
context.install_bundle("spell_dictionary_FR").start()
# Start the spell checker bundle, which provides the spell checker service.
context.install_bundle("spell_checker").start()
# Sample usage of the spell checker service
# 1. get its service reference, that describes the service itself
ref_config = context.get_service_reference("spell_checker_service")
# 2. the use_service method allows to grab a service and to use it inside a
# with block. It automatically releases the service when exiting the block,
# even if an exception was raised
with use_service(context, ref_config) as svc_config:
# Here, svc_config points to the spell checker service
passage = "Welcome to our framwork iPOPO"
print("1. Testing Spell Checker:", passage)
misspelled_words = svc_config.check(passage)
print("> Misspelled_words are:", misspelled_words)
# Start the spell client bundle, which provides a shell command
context.install_bundle("spell_client").start()
# Wait for the framework to stop
framework.wait_for_stop()
|
python
|
{
"resource": ""
}
|
q9586
|
wrap_socket
|
train
|
def wrap_socket(socket, certfile, keyfile, password=None):
"""
Wraps an existing TCP socket and returns an SSLSocket object
:param socket: The socket to wrap
:param certfile: The server certificate file
:param keyfile: The server private key file
:param password: Password for the private key file (Python >= 3.3)
:return: The wrapped socket
:raise SSLError: Error wrapping the socket / loading the certificate
:raise OSError: A password has been given, but ciphered key files are not
supported by the current version of Python
"""
# Log warnings when some
logger = logging.getLogger("ssl_wrap")
def _password_support_error():
"""
Logs a warning and raises an OSError if a password has been given but
Python doesn't support ciphered key files.
:raise OSError: If a password has been given
"""
if password:
logger.error(
"The ssl.wrap_socket() fallback method doesn't "
"support key files with a password."
)
raise OSError(
"Can't decode the SSL key file: "
"this version of Python doesn't support it"
)
try:
# Prefer the default context factory, as it will be updated to reflect
# security issues (Python >= 2.7.9 and >= 3.4)
default_context = ssl.create_default_context()
except AttributeError:
default_context = None
try:
# Try to equivalent to create_default_context() in Python 3.5
# Create an SSL context and set its options
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
if default_context is not None:
# Copy options
context.options = default_context.options
else:
# Set up the context as create_default_context() does in Python 3.5
# SSLv2 considered harmful
# SSLv3 has problematic security
context.options |= ssl.OP_NO_SSLv2 | ssl.OP_NO_SSLv3
# disallow ciphers with known vulnerabilities
context.set_ciphers(_RESTRICTED_SERVER_CIPHERS)
try:
# Load the certificate, with a password
context.load_cert_chain(certfile, keyfile, password)
except TypeError:
# The "password" argument isn't supported
# Check support for key file password
_password_support_error()
# Load the certificate, without the password argument
context.load_cert_chain(certfile, keyfile)
# Return the wrapped socket
return context.wrap_socket(socket, server_side=True)
except AttributeError as ex:
# Log a warning to advise the user of possible security holes
logger.warning(
"Can't create a custom SSLContext. "
"The server should be considered insecure."
)
logger.debug("Missing attribute: %s", ex)
# Check support for key file password
_password_support_error()
# Fall back to the "old" wrap_socket method
return ssl.wrap_socket(
socket, server_side=True, certfile=certfile, keyfile=keyfile
)
|
python
|
{
"resource": ""
}
|
q9587
|
make_html_list
|
train
|
def make_html_list(items, tag="ul"):
# type: (Iterable[Any], str) -> str
"""
Makes a HTML list from the given iterable
:param items: The items to list
:param tag: The tag to use (ul or ol)
:return: The HTML list code
"""
html_list = "\n".join(
'<li><a href="{0}">{0}</a></li>'.format(item) for item in items
)
return "<{0}>\n{1}\n</{0}>".format(tag, html_list)
|
python
|
{
"resource": ""
}
|
q9588
|
AbstractHTTPServletRequest.read_data
|
train
|
def read_data(self):
# type: () -> ByteString
"""
Reads all the data in the input stream
:return: The read data
"""
try:
size = int(self.get_header("content-length"))
except (ValueError, TypeError):
size = -1
return self.get_rfile().read(size)
|
python
|
{
"resource": ""
}
|
q9589
|
AbstractHTTPServletResponse.send_content
|
train
|
def send_content(
self,
http_code,
content,
mime_type="text/html",
http_message=None,
content_length=-1,
):
# type: (int, str, str, str, int) -> None
"""
Utility method to send the given content as an answer.
You can still use get_wfile or write afterwards, if you forced the
content length.
If content_length is negative (default), it will be computed as the
length of the content;
if it is positive, the given value will be used;
if it is None, the content-length header won't be sent.
:param http_code: HTTP result code
:param content: Data to be sent (must be a string)
:param mime_type: Content MIME type (content-type)
:param http_message: HTTP code description
:param content_length: Forced content length
"""
self.set_response(http_code, http_message)
if mime_type and not self.is_header_set("content-type"):
self.set_header("content-type", mime_type)
# Convert the content
raw_content = to_bytes(content)
if content_length is not None and not self.is_header_set(
"content-length"
):
if content_length < 0:
# Compute the length
content_length = len(raw_content)
# Send the length
self.set_header("content-length", content_length)
self.end_headers()
# Send the content
self.write(raw_content)
|
python
|
{
"resource": ""
}
|
q9590
|
make_mreq
|
train
|
def make_mreq(family, address):
"""
Makes a mreq structure object for the given address and socket family.
:param family: A socket family (AF_INET or AF_INET6)
:param address: A multicast address (group)
:raise ValueError: Invalid family or address
"""
if not address:
raise ValueError("Empty address")
# Convert the address to a binary form
group_bin = pton(family, address)
if family == socket.AF_INET:
# IPv4
# struct ip_mreq
# {
# struct in_addr imr_multiaddr; /* IP multicast address of group */
# struct in_addr imr_interface; /* local IP address of interface */
# };
# "=I" : Native order, standard size unsigned int
return group_bin + struct.pack("=I", socket.INADDR_ANY)
elif family == socket.AF_INET6:
# IPv6
# struct ipv6_mreq {
# struct in6_addr ipv6mr_multiaddr;
# unsigned int ipv6mr_interface;
# };
# "@I" : Native order, native size unsigned int
return group_bin + struct.pack("@I", 0)
raise ValueError("Unknown family {0}".format(family))
|
python
|
{
"resource": ""
}
|
q9591
|
create_multicast_socket
|
train
|
def create_multicast_socket(address, port):
"""
Creates a multicast socket according to the given address and port.
Handles both IPv4 and IPv6 addresses.
:param address: Multicast address/group
:param port: Socket port
:return: A tuple (socket, listening address)
:raise ValueError: Invalid address or port
"""
# Get the information about a datagram (UDP) socket, of any family
try:
addrs_info = socket.getaddrinfo(
address, port, socket.AF_UNSPEC, socket.SOCK_DGRAM
)
except socket.gaierror:
raise ValueError(
"Error retrieving address informations ({0}, {1})".format(
address, port
)
)
if len(addrs_info) > 1:
_logger.debug(
"More than one address information found. Using the first one."
)
# Get the first entry : (family, socktype, proto, canonname, sockaddr)
addr_info = addrs_info[0]
# Only accept IPv4/v6 addresses
if addr_info[0] not in (socket.AF_INET, socket.AF_INET6):
# Unhandled address family
raise ValueError("Unhandled socket family : %d" % (addr_info[0]))
# Prepare the socket
sock = socket.socket(addr_info[0], socket.SOCK_DGRAM, socket.IPPROTO_UDP)
# Reuse address
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if hasattr(socket, "SO_REUSEPORT"):
# Special for MacOS
# pylint: disable=E1101
sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
# Bind the socket
if sock.family == socket.AF_INET:
# IPv4 binding
sock.bind(("0.0.0.0", port))
else:
# IPv6 Binding
sock.bind(("::", port))
# Prepare the mreq structure to join the group
# addrinfo[4] = (addr,port)
mreq = make_mreq(sock.family, addr_info[4][0])
# Join the group
if sock.family == socket.AF_INET:
# IPv4
sock.setsockopt(socket.IPPROTO_IP, socket.IP_ADD_MEMBERSHIP, mreq)
# Allow multicast packets to get back on this host
sock.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_LOOP, 1)
elif sock.family == socket.AF_INET6:
# IPv6
sock.setsockopt(ipproto_ipv6(), socket.IPV6_JOIN_GROUP, mreq)
# Allow multicast packets to get back on this host
sock.setsockopt(ipproto_ipv6(), socket.IPV6_MULTICAST_LOOP, 1)
return sock, addr_info[4][0]
|
python
|
{
"resource": ""
}
|
q9592
|
close_multicast_socket
|
train
|
def close_multicast_socket(sock, address):
"""
Cleans up the given multicast socket.
Unregisters it of the multicast group.
Parameters should be the result of create_multicast_socket
:param sock: A multicast socket
:param address: The multicast address used by the socket
"""
if sock is None:
return
if address:
# Prepare the mreq structure to join the group
mreq = make_mreq(sock.family, address)
# Quit group
if sock.family == socket.AF_INET:
# IPv4
sock.setsockopt(socket.IPPROTO_IP, socket.IP_DROP_MEMBERSHIP, mreq)
elif sock.family == socket.AF_INET6:
# IPv6
sock.setsockopt(ipproto_ipv6(), socket.IPV6_LEAVE_GROUP, mreq)
# Close the socket
sock.close()
|
python
|
{
"resource": ""
}
|
q9593
|
HelloImpl.sayHello
|
train
|
def sayHello(self, name="Not given", message="nothing"):
"""
Synchronous implementation of IHello.sayHello synchronous method.
The remote calling thread will be blocked until this is executed and
responds.
"""
print(
"Python.sayHello called by: {0} "
"with message: '{1}'".format(name, message)
)
return (
"PythonSync says: Howdy {0} "
"that's a nice runtime you got there".format(name)
)
|
python
|
{
"resource": ""
}
|
q9594
|
HelloImpl.sayHelloPromise
|
train
|
def sayHelloPromise(self, name="Not given", message="nothing"):
"""
Implementation of IHello.sayHelloPromise.
This method will be executed via some thread, and the remote caller
will not block.
"""
print(
"Python.sayHelloPromise called by: {0} "
"with message: '{1}'".format(name, message)
)
return (
"PythonPromise says: Howdy {0} "
"that's a nice runtime you got there".format(name)
)
|
python
|
{
"resource": ""
}
|
q9595
|
_set_factory_context
|
train
|
def _set_factory_context(factory_class, bundle_context):
# type: (type, Optional[BundleContext]) -> Optional[FactoryContext]
"""
Transforms the context data dictionary into its FactoryContext object form.
:param factory_class: A manipulated class
:param bundle_context: The class bundle context
:return: The factory context, None on error
"""
try:
# Try to get the factory context (built using decorators)
context = getattr(factory_class, constants.IPOPO_FACTORY_CONTEXT)
except AttributeError:
# The class has not been manipulated, or too badly
return None
if not context.completed:
# Partial context (class not manipulated)
return None
# Associate the factory to the bundle context
context.set_bundle_context(bundle_context)
return context
|
python
|
{
"resource": ""
}
|
q9596
|
_IPopoService.__find_handler_factories
|
train
|
def __find_handler_factories(self):
"""
Finds all registered handler factories and stores them
"""
# Get the references
svc_refs = self.__context.get_all_service_references(
handlers_const.SERVICE_IPOPO_HANDLER_FACTORY
)
if svc_refs:
for svc_ref in svc_refs:
# Store each handler factory
self.__add_handler_factory(svc_ref)
|
python
|
{
"resource": ""
}
|
q9597
|
_IPopoService.__add_handler_factory
|
train
|
def __add_handler_factory(self, svc_ref):
# type: (ServiceReference) -> None
"""
Stores a new handler factory
:param svc_ref: ServiceReference of the new handler factory
"""
with self.__handlers_lock:
# Get the handler ID
handler_id = svc_ref.get_property(handlers_const.PROP_HANDLER_ID)
if handler_id in self._handlers:
# Duplicated ID
_logger.warning("Already registered handler ID: %s", handler_id)
else:
# Store the service
self._handlers_refs.add(svc_ref)
self._handlers[handler_id] = self.__context.get_service(svc_ref)
# Try to instantiate waiting components
succeeded = set()
for (
name,
(context, instance),
) in self.__waiting_handlers.items():
if self.__try_instantiate(context, instance):
succeeded.add(name)
# Remove instantiated component from the waiting list
for name in succeeded:
del self.__waiting_handlers[name]
|
python
|
{
"resource": ""
}
|
q9598
|
_IPopoService.__remove_handler_factory
|
train
|
def __remove_handler_factory(self, svc_ref):
# type: (ServiceReference) -> None
"""
Removes an handler factory
:param svc_ref: ServiceReference of the handler factory to remove
"""
with self.__handlers_lock:
# Get the handler ID
handler_id = svc_ref.get_property(handlers_const.PROP_HANDLER_ID)
# Check if this is the handler we use
if svc_ref not in self._handlers_refs:
return
# Clean up
self.__context.unget_service(svc_ref)
self._handlers_refs.remove(svc_ref)
del self._handlers[handler_id]
# List the components using this handler
to_stop = set() # type: Set[StoredInstance]
for factory_name in self.__factories:
_, factory_context = self.__get_factory_with_context(
factory_name
)
if handler_id in factory_context.get_handlers_ids():
to_stop.update(self.__get_stored_instances(factory_name))
with self.__instances_lock:
for stored_instance in to_stop:
# Extract information
context = stored_instance.context
name = context.name
instance = stored_instance.instance
# Clean up the stored instance (iPOPO side)
del self.__instances[name]
stored_instance.kill()
# Add the component to the waiting queue
self.__waiting_handlers[name] = (context, instance)
# Try to find a new handler factory
new_ref = self.__context.get_service_reference(
handlers_const.SERVICE_IPOPO_HANDLER_FACTORY,
"({0}={1})".format(handlers_const.PROP_HANDLER_ID, handler_id),
)
if new_ref is not None:
self.__add_handler_factory(new_ref)
|
python
|
{
"resource": ""
}
|
q9599
|
_IPopoService.__get_factory_with_context
|
train
|
def __get_factory_with_context(self, factory_name):
# type: (str) -> Tuple[type, FactoryContext]
"""
Retrieves the factory registered with the given and its factory context
:param factory_name: The name of the factory
:return: A (factory, context) tuple
:raise TypeError: Unknown factory, or factory not manipulated
"""
factory = self.__factories.get(factory_name)
if factory is None:
raise TypeError("Unknown factory '{0}'".format(factory_name))
# Get the factory context
factory_context = getattr(
factory, constants.IPOPO_FACTORY_CONTEXT, None
)
if factory_context is None:
raise TypeError(
"Factory context missing in '{0}'".format(factory_name)
)
return factory, factory_context
|
python
|
{
"resource": ""
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.