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
484455
def prepare_endpoint_props(self, intfs, svc_ref, export_props):
        # type: (List[str], ServiceReference, Dict[str, Any]) -> Dict[str, Any]
        
        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
714847
def decode_osgi_props(input_props):
    # type: (Dict[str, Any]) -> Dict[str, Any]
    
    result_props = {}
    intfs = decode_list(input_props, OBJECTCLASS)
    result_props[OBJECTCLASS] = intfs
    for intf in intfs:
        package_key = ENDPOINT_PACKAGE_VERSION_ + package_name(intf)
        intfversionstr = input_props.get(package_key, None)
        if intfversionstr:
            result_props[package_key] = intfversionstr
    result_props[ENDPOINT_ID] = input_props[ENDPOINT_ID]
    result_props[ENDPOINT_SERVICE_ID] = input_props[ENDPOINT_SERVICE_ID]
    result_props[ENDPOINT_FRAMEWORK_UUID] = input_props[ENDPOINT_FRAMEWORK_UUID]
    imp_configs = decode_list(input_props, SERVICE_IMPORTED_CONFIGS)
    if imp_configs:
        result_props[SERVICE_IMPORTED_CONFIGS] = imp_configs
    intents = decode_list(input_props, SERVICE_INTENTS)
    if intents:
        result_props[SERVICE_INTENTS] = intents
    remote_configs = decode_list(input_props, REMOTE_CONFIGS_SUPPORTED)
    if remote_configs:
        result_props[REMOTE_CONFIGS_SUPPORTED] = remote_configs
    remote_intents = decode_list(input_props, REMOTE_INTENTS_SUPPORTED)
    if remote_intents:
        result_props[REMOTE_INTENTS_SUPPORTED] = remote_intents
    return result_props
1145283
private void setUpInternalProperties() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.entry(tc, "setUpInternalProperties");
        }

        if (getLocation() != null) {
            // KEYSTORE CUSTOM PROPERTIES
            Map<String, String> otherProps = getCustomProps();
            if (otherProps != null) {
                for (Entry<String, String> current : otherProps.entrySet()) {
                    setProperty(current.getKey(), current.getValue());
                }
            }

            // load as key store
            String keyStoreProvider = getProvider();
            if (keyStoreProvider != null) {
                setProperty(Constants.SSLPROP_KEY_STORE_PROVIDER, keyStoreProvider);
            }

            // KEYSTORE NAME
            String keyStoreName = getName();
            if (keyStoreName != null) {
                setProperty(Constants.SSLPROP_KEY_STORE_NAME, keyStoreName);
            }

            // KEYSTORE PASSWORD
            String keyStorePassword = getPassword();
            if (keyStorePassword != null) {
                setProperty(Constants.SSLPROP_KEY_STORE_PASSWORD, keyStorePassword);
            }

            // KEYSTORE LOCATION
            String keyStoreLocation = getLocation();
            if (keyStoreLocation != null) {
                setProperty(Constants.SSLPROP_KEY_STORE, keyStoreLocation);
            }

            // KEYSTORE IS FILE BASED
            if (getFileBased() != null) {
                setProperty(Constants.SSLPROP_KEY_STORE_FILE_BASED, getFileBased().toString());
            }

            // KEYSTORE TYPE
            String keyStoreType = getType();
            if (keyStoreType != null) {
                setProperty(Constants.SSLPROP_KEY_STORE_TYPE, keyStoreType);

                if (!keyStoreType.equalsIgnoreCase(Constants.KEYSTORE_TYPE_JKS) && !keyStoreType.equalsIgnoreCase(Constants.KEYSTORE_TYPE_JCEKS)
                    && !keyStoreType.equalsIgnoreCase(Constants.KEYSTORE_TYPE_PKCS12)) {
                    setProperty(Constants.SSLPROP_KEY_STORE_FILE_BASED, Constants.FALSE);
                }

                if (keyStoreType.equalsIgnoreCase(Constants.KEYSTORE_TYPE_JAVACRYPTO)) {
                    setProperty(Constants.SSLPROP_TOKEN_ENABLED, Constants.TRUE);

                    // set appropriate provider for jvm vendor
                    if (JavaInfo.vendor().equals(JavaInfo.Vendor.IBM))
                        setProperty(Constants.SSLPROP_KEY_STORE_PROVIDER, IBMPKCS11Impl_PROVIDER_NAME);
                    else
                        setProperty(Constants.SSLPROP_KEY_STORE_PROVIDER, SUNPKCS11_PROVIDER_NAME);
                }
            }

            // KEYSTORE IS READ ONLY
            if (getReadOnly() != null)
                setProperty(Constants.SSLPROP_KEY_STORE_READ_ONLY, getReadOnly().toString());

            // KEYSTORE IS INITIALIZED AT STARTUP
            if (getInitializeAtStartup() != null)
                setProperty(Constants.SSLPROP_KEY_STORE_INITIALIZE_AT_STARTUP, getInitializeAtStartup().toString());

            // KEYSTORE STASH FOR CMS
            if (getStashFile() != null)
                setProperty(Constants.SSLPROP_KEY_STORE_CREATE_CMS_STASH, getStashFile().toString());

        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "setUpInternalProperties");
        }
    }
632475
def get_edef_props(
    object_class,
    exported_cfgs,
    ep_namespace,
    ep_id,
    ecf_ep_id,
    ep_rsvc_id,
    ep_ts,
    remote_intents=None,
    fw_id=None,
    pkg_ver=None,
    service_intents=None,
):
    
    osgi_props = get_rsa_props(
        object_class,
        exported_cfgs,
        remote_intents,
        ep_rsvc_id,
        fw_id,
        pkg_ver,
        service_intents,
    )
    ecf_props = get_ecf_props(ecf_ep_id, ep_namespace, ep_rsvc_id, ep_ts)
    return merge_dicts(osgi_props, ecf_props)
394395
def _export_service(self, svc, ed):
        # type: (Any, EndpointDescription) -> None
        
        self._add_export(ed.get_id(), (svc, ed))
934999
private void setProperties(Properties properties) {
        Props props = new Props(properties);
        if(props.containsKey(BOOTSTRAP_URLS_PROPERTY)) {
            setBootstrapURLs(props.getList(BOOTSTRAP_URLS_PROPERTY));
        }

        if(props.containsKey(FAT_CLIENTS_CONFIG_SOURCE)) {
            setFatClientConfigSource(StoreClientConfigSource.get(props.getString(FAT_CLIENTS_CONFIG_SOURCE)));
        }

        if(props.containsKey(FAT_CLIENTS_CONFIG_FILE_PATH_PROPERTY)) {
            setFatClientConfigPath(props.getString(FAT_CLIENTS_CONFIG_FILE_PATH_PROPERTY));
        }

        if(props.containsKey(METADATA_CHECK_INTERVAL_IN_MS)) {
            setMetadataCheckIntervalInMs(props.getInt(METADATA_CHECK_INTERVAL_IN_MS));
        }

        if(props.containsKey(NETTY_SERVER_PORT)) {
            setServerPort(props.getInt(NETTY_SERVER_PORT));
        }

        if(props.containsKey(NETTY_SERVER_BACKLOG)) {
            setNettyServerBacklog(props.getInt(NETTY_SERVER_BACKLOG));
        }

        if(props.containsKey(COORDINATOR_CORE_THREADS)) {
            setCoordinatorCoreThreads(props.getInt(COORDINATOR_CORE_THREADS));
        }

        if(props.containsKey(COORDINATOR_MAX_THREADS)) {
            setCoordinatorMaxThreads(props.getInt(COORDINATOR_MAX_THREADS));
        }

        if(props.containsKey(COORDINATOR_QUEUED_REQUESTS)) {
            setCoordinatorQueuedRequestsSize(props.getInt(COORDINATOR_QUEUED_REQUESTS));
        }

        if(props.containsKey(HTTP_MESSAGE_DECODER_MAX_INITIAL_LINE_LENGTH)) {
            setHttpMessageDecoderMaxInitialLength(props.getInt(HTTP_MESSAGE_DECODER_MAX_INITIAL_LINE_LENGTH));
        }

        if(props.containsKey(HTTP_MESSAGE_DECODER_MAX_HEADER_SIZE)) {
            setHttpMessageDecoderMaxHeaderSize(props.getInt(HTTP_MESSAGE_DECODER_MAX_HEADER_SIZE));
        }

        if(props.containsKey(HTTP_MESSAGE_DECODER_MAX_CHUNK_SIZE)) {
            setHttpMessageDecoderMaxChunkSize(props.getInt(HTTP_MESSAGE_DECODER_MAX_CHUNK_SIZE));
        }

        if(props.containsKey(ADMIN_ENABLE)) {
            setAdminServiceEnabled(props.getBoolean(ADMIN_ENABLE));
        }

        if(props.containsKey(ADMIN_PORT)) {
            setAdminPort(props.getInt(ADMIN_PORT));
        }

    }
1202841
public void prepareEndPoint(CFEndPointImpl endpoint) throws ChannelFrameworkException {
        if (null == endpoint.getOutboundChainData()) {
            VirtualConnectionFactory vcf = getOutboundVCFactory(endpoint.getOutboundChannelDefs());
            endpoint.setOutboundVCFactory(vcf);
            endpoint.setOutboundChainData(getChain(vcf.getName()));
        }
    }
1339014
def set_properties(self, properties):
        
        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)
1056025
private void setAttributesFromApiEndpointProperties(Api api, ApimanHttpConnectorOptions options) {
        try {
            Map<String, String> endpointProperties = api.getEndpointProperties();
            if (endpointProperties.containsKey("timeouts.read")) { //$NON-NLS-1$
                int connectTimeoutMs = Integer.parseInt(endpointProperties.get("timeouts.read")); //$NON-NLS-1$
                options.setRequestTimeout(connectTimeoutMs);
            }
            if (endpointProperties.containsKey("timeouts.connect")) { //$NON-NLS-1$
                int connectTimeoutMs = Integer.parseInt(endpointProperties.get("timeouts.connect")); //$NON-NLS-1$
                options.setConnectionTimeout(connectTimeoutMs);
            }
        } catch (NumberFormatException e) {
            throw new RuntimeException(e);
        }
    }
428915
def _get_service_endpoint(context, svc, region=None, public=True):
    
    region = _safe_region(region)
    # If a specific context is passed, use that. Otherwise, use the global
    # identity reference.
    context = context or identity
    url_type = {True: "public", False: "private"}[public]
    svc_obj = context.services.get(svc)
    if not svc_obj:
        return None
    ep = svc_obj.endpoints.get(region, {}).get(url_type)
    if not ep:
        # Try the "ALL" region, and substitute the actual region
        ep = svc_obj.endpoints.get("ALL", {}).get(url_type)
    return ep
889889
public static synchronized final void init ( Properties props ) throws CIFSException {
        if ( INSTANCE != null ) {
            throw new CIFSException("Singleton context is already initialized");
        }
        Properties p = new Properties();
        try {
            String filename = System.getProperty("jcifs.properties");
            if ( filename != null && filename.length() > 1 ) {

                try ( FileInputStream in = new FileInputStream(filename) ) {
                    p.load(in);
                }
            }

        }
        catch ( IOException ioe ) {
            log.error("Failed to load config", ioe); //$NON-NLS-1$
        }
        p.putAll(System.getProperties());
        if ( props != null ) {
            p.putAll(props);
        }
        INSTANCE = new SingletonContext(p);
    }
382320
def pelix_services(self):
        
        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)
        }
893186
def set_transform_interface_params(spec, input_features, output_features, are_optional = False):
    
    input_features = _fm.process_or_validate_features(input_features)
    output_features = _fm.process_or_validate_features(output_features)

    # Add input and output features
    for (fname, ftype) in input_features:
        input_ = spec.description.input.add()
        input_.name = fname
        datatypes._set_datatype(input_.type, ftype)
        if are_optional:
            input_.type.isOptional = are_optional

    for (fname, ftype) in output_features:
        output_ = spec.description.output.add()
        output_.name = fname
        datatypes._set_datatype(output_.type, ftype)

    return spec
445024
@Bind(id = "exporterServices", specification = ExporterService.class, aggregate = true, optional = true)
    void bindExporterService(ServiceReference<ExporterService> serviceReference) {
        synchronized (lock) {
            try {
                exportersManager.add(serviceReference);
            } catch (InvalidFilterException invalidFilterException) {
                LOG.error("The ServiceProperty \"" + TARGET_FILTER_PROPERTY + "\" of the ExporterService "
                                + bundleContext.getService(serviceReference) + " doesn't provides a valid Filter."
                                + " To be used, it must provides a correct \"" + TARGET_FILTER_PROPERTY + "\" ServiceProperty.",
                        invalidFilterException
                );
                return;
            }
            if (!exportersManager.matched(serviceReference)) {
                return;
            }
            LOG.debug(linkerName + " : Bind the ExporterService "
                    + exportersManager.getDeclarationBinder(serviceReference)
                    + " with filter " + exportersManager.getTargetFilter(serviceReference));
            exportersManager.createLinks(serviceReference);
        }
    }
815211
static public void setPropertiesInSMC(SessionManagerConfig smc, Map<String, Object> xtpProperties) {
        final String methodName = "setPropertiesInSMC";
        final String invalidPropFoundMessage = "SessionContext.invalidPropertyFound";
        final String invalidCloneSeparatorMessage = "SessionContext.invalidCloneSeparator";
        String strProp = null;
        Boolean booleanProp;
        Integer integerProp = null;

        boolean baseServerLevelConfig = smc.isUsingWebContainerSM();

        setDefaultConfiguration(smc, xtpProperties);

        // id length - has upper case D for system property...maintain for
        // compatibility
        final String propIdLengthForSys = "HttpSessionIDLength";
        final String propIdLength = "idLength";
        int idLength = -1;

        Object propIdLengthValue = xtpProperties.get(propIdLength);
        if (propIdLengthValue instanceof Integer) {
            integerProp = (Integer) propIdLengthValue;
        } else {
            strProp = (String) propIdLengthValue;
            if (strProp == null) {
                strProp = getSystemProperty(propIdLength);
                // look for different case on system property
                if (strProp == null) {
                    strProp = getSystemProperty(propIdLengthForSys);
                }
            }
        }

        if (integerProp != null || strProp != null) {
            try {
                if (integerProp != null) {
                    idLength = integerProp.intValue();
                } else {
                    idLength = Integer.parseInt(strProp);
                }
                if ((idLength < 8) || (idLength > 128)) {
                    if (idLength < 8)
                        idLength = 8;
                    if (idLength > 128)
                        idLength = 128;
                    LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, "SessionContext.valueOutOfRange", new Object[] { propIdLength, strProp,
                                                                                                                                                     new Integer(idLength) });
                }
                if (shouldSetAndDoLogging(propIdLength, true, baseServerLevelConfig, xtpProperties, new Integer(idLength), new Integer(SessionManagerConfig.getSessionIDLength()),
                                          false)) {
                    SessionManagerConfig.setSessionIDLength(idLength);
                }
            } catch (NumberFormatException nfe) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propIdLength, strProp });
            }
        }

        // id reuse - reuse incoming id even if its not in use by another webapp
        final String propIdReuse = "HttpSessionIdReuse";
        strProp = getStringProperty(propIdReuse, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propIdReuse, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isIdReuse()), false)) {
                SessionManagerConfig.setIdReuse(booleanProp.booleanValue());
            }
        }

        // track gc
        final String propTrackGC = "HttpSessionTrackGC";
        strProp = getStringProperty(propTrackGC, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propTrackGC, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setTrackGCCount(booleanProp.booleanValue());
            }
        }

        // reaper poll interval - override how often inval thread runs
        final String propReaperPollInt = "HttpSessionReaperPollInterval";
        strProp = getStringProperty(propReaperPollInt, xtpProperties);
        long longProp = -1;
        try {
            if (strProp != null) {
                if (shouldSetAndDoLogging(propReaperPollInt, false, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                    longProp = new Long(strProp).longValue();
                    smc.setReaperPollInterval(longProp);
                }
            }
        } catch (NumberFormatException nfe) {
            LoggingUtil.SESSION_LOGGER_CORE.logp(Level.SEVERE, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propReaperPollInt, strProp });
        }

        // use invalidated id - default to true for better performance
        final String propUseRecentInvalId = "UseInvalidatedId";
        strProp = getStringProperty(propUseRecentInvalId, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propUseRecentInvalId, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setCheckRecentlyInvalidList(booleanProp.booleanValue());
            }
        }

        // debug session crossover
        final String propDebugSessCross = "DebugSessionCrossover";
        strProp = getStringProperty(propDebugSessCross, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propDebugSessCross, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setDebugSessionCrossover(booleanProp.booleanValue());
                if (baseServerLevelConfig || xtpProperties.get(propDebugSessCross) != null) {
                    if (booleanProp.booleanValue() == true) {
                        LoggingUtil.SESSION_LOGGER_CORE.logp(Level.INFO, methodClassName, methodName, "SessionContext.DebugCrossoverEnabled");
                    }
                }
            }
        }

        // url rewrite identifier
        final String propSessRewrite = "SessionRewriteIdentifier";
        strProp = getStringProperty(propSessRewrite, xtpProperties);
        if (strProp != null) {
            if (shouldSetAndDoLogging(propSessRewrite, false, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                smc.setSessUrlRewritePrefix(";" + strProp + "=");
            }
        }

        // clone id
        final String propHttpSessionCloneId = "HttpSessionCloneId";
        strProp = getStringProperty(propHttpSessionCloneId, xtpProperties);
        if (strProp != null) {
            if (shouldSetAndDoLogging(propHttpSessionCloneId, true, baseServerLevelConfig, xtpProperties, strProp, SessionManagerConfig.getCloneId(),
                                      strProp.equals(SessionManagerConfig.getCloneId()))) {
                SessionManagerConfig.setCloneId(strProp);
                SessionManagerConfig.setCloneIdPropertySet(true);
            }
        }

        // no additional session info - eliminates cache and clone on base server
        final String propNoAddSessInfo = "NoAdditionalSessionInfo";
        strProp = getStringProperty(propNoAddSessInfo, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propNoAddSessInfo, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isTurnOffCacheId()), false)) {
                SessionManagerConfig.setTurnOffCacheId(booleanProp.booleanValue());
                SessionManagerConfig.setTurnOffCloneId(booleanProp.booleanValue());
                if (smc.isUsingMemory()) {
                    SessionManagerConfig.setCacheIdLength(0);
                }
            }
        }

        // session id max length (including all clones)
        final String propSessIdMax = "SessionIdentifierMaxLength";
        strProp = getStringProperty(propSessIdMax, xtpProperties);
        if (strProp != null) {
            try {
                int maxLength = Integer.parseInt(strProp);
                if (shouldSetAndDoLogging(propSessIdMax, true, baseServerLevelConfig, xtpProperties, new Integer(maxLength),
                                          new Integer(SessionManagerConfig.getMaxSessionIdentifierLength()), false)) {
                    SessionManagerConfig.setMaxSessionIdentifierLength(maxLength);
                }
            } catch (NumberFormatException nfe) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propSessIdMax, strProp });
            }
        }

        // clone separator change
        final String propCloneSepChange = "CloneSeparatorChange";
        strProp = getStringProperty(propCloneSepChange, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propCloneSepChange, true, baseServerLevelConfig, xtpProperties, booleanProp,
                                      Boolean.valueOf('+' == SessionManagerConfig.getCloneSeparator()),
                                      false)) {
                if (booleanProp.booleanValue()) {
                    SessionManagerConfig.setCloneSeparator('+');
                }
            }
        }

        // PM02068 Property for changing CloneSeparator.  
        final String propCloneSeparator = "CloneSeparator";
        strProp = getStringProperty(propCloneSeparator, xtpProperties);
        if (strProp != null) {
            // Must be exactly one char, and cannot be space
            if ((strProp.length() == 1) && (strProp.trim().length() == 1)) {
                if (shouldSetAndDoLogging(propCloneSeparator, true, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                    char charProp = strProp.charAt(0);
                    SessionManagerConfig.setCloneSeparator(charProp);
                }
            } else {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidCloneSeparatorMessage,
                                                     new Object[] { strProp });
            }
        }

        // no affinity switch back - stick to new server after failover
        final String propNoAffSwitch = "NoAffinitySwitchBack";
        strProp = getStringProperty(propNoAffSwitch, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propNoAffSwitch, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isNoAffinitySwitchBack()),
                                      false)) {
                SessionManagerConfig.setNoAffinitySwitchBack(booleanProp.booleanValue());
            }
        }

        // use oracle BLOB, rather than long raw, for medium db column
        final String propUseOracleBlob = "UseOracleBLOB";
        strProp = getStringProperty(propUseOracleBlob, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propUseOracleBlob, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setUseOracleBlob(booleanProp.booleanValue());
            }
        }

        // START: PM37139 Users who set this property to true should have already created their own index, so we skip index creation
        final String propSessionTableSkipIndexCreation = "SessionTableSkipIndexCreation";
        strProp = getStringProperty(propSessionTableSkipIndexCreation, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propSessionTableSkipIndexCreation, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setSessionTableSkipIndexCreation(booleanProp.booleanValue());
            }
        }
        // END: PM37139

        // START: PM57590
        final String propCheckSessionNewOnIsValidRequest = "CheckSessionNewOnIsValidRequest";
        strProp = getStringProperty(propCheckSessionNewOnIsValidRequest, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propCheckSessionNewOnIsValidRequest, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setCheckSessionNewOnIsValidRequest(booleanProp.booleanValue());
            }
        }
        // END: PM57590     

        // if the data source has a non default schema name, then we need to mark it as so
        final String propUsingCurrentSchemaCustomProperty = "UsingCustomSchemaName";
        strProp = getStringProperty(propUsingCurrentSchemaCustomProperty, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propUsingCurrentSchemaCustomProperty, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setUsingCustomSchemaName(booleanProp.booleanValue());
            }
        }

        // hide session values (in trace output)
        final String propHideSessVals = "HideSessionValues";
        strProp = getStringProperty(propHideSessVals, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propHideSessVals, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isHideSessionValues()), false)) {
                SessionManagerConfig.setHideSessionValues(booleanProp.booleanValue());
                SessionManagerConfig.setHideSessionValuesPropertySet(true);
            }
        }

        // do remote invalidations - forces inval even if scheduled session inval
        // (twice a day) is enabled
        final String propDoRemoteInval = "DoRemoteInvalidations";
        strProp = getStringProperty(propDoRemoteInval, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propDoRemoteInval, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isDoRemoteInvalidations()),
                                      false)) {
                SessionManagerConfig.setDoRemoteInvalidations(booleanProp.booleanValue());
            }
        }
        // session table name
        final String propSessTable = "SessionTableName";
        strProp = getStringProperty(propSessTable, xtpProperties);
        if (strProp != null) {
            if (shouldSetAndDoLogging(propSessTable, false, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                smc.setTableNameValue(strProp);
            }
        }

        // zOS Base Server Replication
        final String propZosBaseServerReplication = "HttpSessionEnableUnmanagedServerReplication";
        strProp = getStringProperty(propZosBaseServerReplication, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propZosBaseServerReplication, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setZosBaseServerReplicationEnabled(booleanProp.booleanValue());
            }
        }

        // servlet 21 compatibility -- aka global sessions
        final String propServlet21SessionCompat = "Servlet21SessionCompatibility";
        strProp = getStringProperty(propServlet21SessionCompat, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propServlet21SessionCompat, true, baseServerLevelConfig, xtpProperties, booleanProp,
                                      Boolean.valueOf(SessionManagerConfig.getServlet21SessionCompatibility()), false)) {
                SessionManagerConfig.setServlet21SessionCompatibility(booleanProp.booleanValue());
            }
        }

        // always encode the url even if cookies enabled is set
        final String propAlwaysEncode = "AlwaysEncodeURL";
        strProp = getStringProperty(propAlwaysEncode, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propAlwaysEncode, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isAlwaysEncodeURL()), false)) {
                SessionManagerConfig.setAlwaysEncodeURL(booleanProp.booleanValue());
            }
        }
        
        // START: PM81933 Check session cookie name on EncodeURL method
        final String propCheckSessionCookieNameOnEncodeURL = "CheckSessionCookieNameOnEncodeURL";
        strProp = getStringProperty(propCheckSessionCookieNameOnEncodeURL, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propCheckSessionCookieNameOnEncodeURL, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.checkSessionCookieNameOnEncodeURL()), false)) {
                SessionManagerConfig.setCheckSessionCookieNameOnEncodeURL(booleanProp.booleanValue());
            }
        }
        // END: PM81933        

        // Optimizes the Version Increments if the in-memory session is the same as
        // the one stored on the backend. This property only applies to non-EOS
        // writes since we will always do this for EOS.
        final String propOptimizeCacheIdIncrements = "OptimizeCacheIdIncrements";
        strProp = getStringProperty(propOptimizeCacheIdIncrements, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propOptimizeCacheIdIncrements, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setOptimizeCacheIdIncrements(booleanProp.booleanValue());
            }
        }

        // only checks the cache vs the backend for updating the lastAccessedTime
        // during the preInvoke metho
        final String propOnlyCheckInCacheDuringPreInvoke = "OnlyCheckInCacheDuringPreInvoke";
        strProp = getStringProperty(propOnlyCheckInCacheDuringPreInvoke, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propOnlyCheckInCacheDuringPreInvoke, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setOnlyCheckInCacheDuringPreInvoke(booleanProp.booleanValue());
            }
        }

        // can be used to disable hot failover by setting to false - default is true
        final String propEnableHotFailover = "EnableHotFailover";
        strProp = getStringProperty(propEnableHotFailover, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propEnableHotFailover, true, baseServerLevelConfig, xtpProperties, booleanProp, Boolean.valueOf(SessionManagerConfig.isEnableHotFailover()),
                                      false)) {
                SessionManagerConfig.setEnableHotFailover(booleanProp.booleanValue());
            }
        }

        // PK38538 Begin
        final String propForceSessionInvalidationMultiple = "ForceSessionInvalidationMultiple";
        strProp = getStringProperty(propForceSessionInvalidationMultiple, xtpProperties);
        if (strProp != null) {
            try {
                int invalMult = new Integer(strProp).intValue();
                if (shouldSetAndDoLogging(propForceSessionInvalidationMultiple, false, baseServerLevelConfig, xtpProperties, new Integer(invalMult), null, false)) {
                    smc.setForceSessionInvalidationMultiple(invalMult);
                }
            } catch (NumberFormatException nfe) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propForceSessionInvalidationMultiple,
                                                                                                                                        strProp });
            }
        } // PK38538 End
        
        //PI73188 Start
        final String propModifyActiveCountOnInvalidatedSession = "ModifyActiveCountOnInvalidatedSession";
        strProp = getStringProperty(propModifyActiveCountOnInvalidatedSession, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propModifyActiveCountOnInvalidatedSession, true, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setModifyActiveCountOnInvalidatedSession(booleanProp.booleanValue());
            }
        }
        //PI73188 End
        
        
        final String propPersistSessionAfterPassivation = "PersistSessionAfterPassivation";
        strProp = getStringProperty(propPersistSessionAfterPassivation, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propPersistSessionAfterPassivation, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setPersistSessionAfterPassivation(booleanProp.booleanValue());
            }
        }

        final String propUsingApplicationSessionsAndInvalidateAll = "UsingApplicationSessionsAndInvalidateAll";
        strProp = getStringProperty(propUsingApplicationSessionsAndInvalidateAll, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propUsingApplicationSessionsAndInvalidateAll, true, baseServerLevelConfig, xtpProperties, booleanProp,
                                      Boolean.valueOf(SessionManagerConfig.getUsingApplicationSessionsAndInvalidateAll()), false)) {
                SessionManagerConfig.setUsingApplicationSessionsAndInvalidateAll(booleanProp.booleanValue());
            }
        }

        final String propUsingApplicationSessionsAlwaysRetrieve = "UsingApplicationSessionsAlwaysRetrieve";
        strProp = getStringProperty(propUsingApplicationSessionsAlwaysRetrieve, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propUsingApplicationSessionsAlwaysRetrieve, true, baseServerLevelConfig, xtpProperties, booleanProp,
                                      Boolean.valueOf(SessionManagerConfig.getUsingApplicationSessionsAlwaysRetrieve()), false)) {
                SessionManagerConfig.setUsingApplicationSessionsAlwaysRetrieve(booleanProp.booleanValue());
            }
        }

        // clone id
        final String propSIPCookieName = "SIPCookieName";
        strProp = getStringProperty(propSIPCookieName, xtpProperties);
        if (strProp != null) {
            if (shouldSetAndDoLogging(propSIPCookieName, true, baseServerLevelConfig, xtpProperties, strProp, SessionManagerConfig.getSipSessionCookieName(),
                                      strProp.equals(SessionManagerConfig.getSipSessionCookieName()))) {
                SessionManagerConfig.setSipSessionCookieName(strProp);
            }
        }
        
        //Property that allows the thread scheduler to be changed
        final String newScheduler= "UseSeparateSessionInvalidatorThreadPool";
        strProp = getStringProperty(newScheduler, xtpProperties);
        if(strProp != null){
            booleanProp=Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(newScheduler, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setUseSeparateSessionInvalidatorThreadPool(booleanProp.booleanValue());
            }
        }        

        //PM74718 Property to control how long to delay the start of the invalidation alarm.
        final String invalidatorAlarmDelay = "DelayInvalidationAlarmDuringServerStartup";
        strProp = getStringProperty(invalidatorAlarmDelay, xtpProperties);
        if (strProp != null) {
            try {
                Integer delayProp = Integer.valueOf(strProp);
                if (shouldSetAndDoLogging(invalidatorAlarmDelay, false, baseServerLevelConfig, xtpProperties, delayProp, null, false)) {
                    smc.setDelayForInvalidationAlarmDuringServerStartup(delayProp.intValue());
                }
            } catch (NumberFormatException nfe) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage,new Object[] {invalidatorAlarmDelay, strProp});
            }
        }

        // PK80439 Property for preventing session ids longer than the permissible length getting created
        final String propForceSessionIdLengthCheck = "ForceSessionIdLengthCheck";
        strProp = getStringProperty(propForceSessionIdLengthCheck, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(propForceSessionIdLengthCheck, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setForceSessionIdLengthCheck(booleanProp.booleanValue());
            }
        }
        // PK80439 End

        // PM04304 Property for ignoring case while comparing session owner and authorized user
        final String securityUserIgnoreCase = "SecurityUserIgnoreCase";
        strProp = getStringProperty(securityUserIgnoreCase, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(securityUserIgnoreCase, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setSecurityUserIgnoreCase(booleanProp.booleanValue());
            }
        }

        //712446
        final String throwSecurityExceptionOnGetSessionFalse = "ThrowSecurityExceptionOnGetSessionFalse";
        strProp = getStringProperty(throwSecurityExceptionOnGetSessionFalse, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(throwSecurityExceptionOnGetSessionFalse, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false)) {
                smc.setThrowSecurityExceptionOnGetSessionFalse(booleanProp.booleanValue());
            }
        }

        final String invalidateOnUnauthorizedSessionRequestException = "InvalidateOnUnauthorizedSessionRequestException";
        strProp = getStringProperty(invalidateOnUnauthorizedSessionRequestException, xtpProperties);
        if (strProp != null) {
            booleanProp = Boolean.valueOf(strProp);
            if (shouldSetAndDoLogging(invalidateOnUnauthorizedSessionRequestException, false, baseServerLevelConfig, xtpProperties, booleanProp, null, false))
                smc.setInvalidateOnUnauthorizedSessionRequestException(booleanProp.booleanValue());
        }
        
        
        // PI18177 We will check incoming cloneIds against this string, needs HttpSessionCloneId to be set to take effect
        final String expectedCloneIds = "ExpectedCloneIds";
        strProp = getStringProperty(expectedCloneIds, xtpProperties);
        if (strProp != null) {
            if (shouldSetAndDoLogging(expectedCloneIds, true, baseServerLevelConfig, xtpProperties, strProp, null, false)) {
                SessionManagerConfig.setExpectedCloneIds(strProp);
                SessionManagerConfig.setExpectedCloneIdsPropertySet(true);
            }
        }
        
        // Feature 68570 Begin
        final String propConnectionRetryCount = "ConnectionRetryCount";
        strProp = getStringProperty(propConnectionRetryCount, xtpProperties);
        if (strProp != null) {
            try {
                int retryCount = new Integer(strProp).intValue();
                if (shouldSetAndDoLogging(propConnectionRetryCount, false, baseServerLevelConfig, xtpProperties, new Integer(retryCount), null, false)) {
                    smc.setConnectionRetryCount(retryCount);
                }
            } catch (NumberFormatException nfe) {
                LoggingUtil.SESSION_LOGGER_CORE.logp(Level.WARNING, methodClassName, methodName, invalidPropFoundMessage, new Object[] { propConnectionRetryCount,
                                                                                                                                        strProp });
            }
        } // Feature 68570 End

    }
333487
@Reference(service = VirtualHost.class,
               target = "(&(enabled=true)(id=default_host)(httpsAlias=*))",
               policy = ReferencePolicy.STATIC,
               cardinality = ReferenceCardinality.MANDATORY)
    protected void setVirtualHost(VirtualHost vhost, Map<String, Object> props) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEventEnabled()) {
            Tr.event(tc, "Set vhost: ", vhost);
        }
        secureVirtualHost = vhost;
        secureAlias = props.get("httpsAlias").toString();
        createJMXWorkAreaResourceIfChanged(vhost);
    }
1007468
def on_service_departure(self, svc_ref):
        
        with self._lock:
            try:
                # Get the service instance
                service = self.services.pop(svc_ref)
            except KeyError:
                # Not a known service reference: ignore
                pass
            else:
                # Clean the instance values
                self._future_value.remove(service)

                # Nullify the value if needed
                if not self._future_value:
                    self._future_value = None

                self._ipopo_instance.unbind(self, service, svc_ref)
                return True

            return None