Set the standard property for setting the no-namespace schema location

@param aMarshaller
The marshaller to set the property. May not be <code>null</code>.
@param sSchemaLocation
the value to be set
348040
public static void setNoNamespaceSchemaLocation (@Nonnull final Marshaller aMarshaller,
                                                   @Nullable final String sSchemaLocation)
  {
    _setProperty (aMarshaller, Marshaller.JAXB_NO_NAMESPACE_SCHEMA_LOCATION, sSchemaLocation);
  }
649567
public static void setSunCharacterEscapeHandler (@Nonnull final Marshaller aMarshaller,
                                                   @Nonnull final Object aCharacterEscapeHandler)
  {
    final String sPropertyName = SUN_ENCODING_HANDLER2;
    _setProperty (aMarshaller, sPropertyName, aCharacterEscapeHandler);
  }
808831
protected void customizeMarshaller(Marshaller marshaller) {
		marshaller.setValidation(this.validating);
		marshaller.setSuppressNamespaces(this.suppressNamespaces);
		marshaller.setSuppressXSIType(this.suppressXsiType);
		marshaller.setMarshalAsDocument(this.marshalAsDocument);
		marshaller.setMarshalExtendedType(this.marshalExtendedType);
		marshaller.setRootElement(this.rootElement);
		marshaller.setNoNamespaceSchemaLocation(this.noNamespaceSchemaLocation);
		marshaller.setSchemaLocation(this.schemaLocation);
		marshaller.setUseXSITypeAtRoot(this.useXSITypeAtRoot);
		if (this.doctypes != null) {
			for (Map.Entry<String, String> doctype : this.doctypes.entrySet()) {
				marshaller.setDoctype(doctype.getKey(), doctype.getValue());
			}
		}
		if (this.processingInstructions != null) {
			for (Map.Entry<String, String> processingInstruction : this.processingInstructions.entrySet()) {
				marshaller.addProcessingInstruction(processingInstruction.getKey(), processingInstruction.getValue());
			}
		}
		if (this.namespaceMappings != null) {
			for (Map.Entry<String, String> entry : this.namespaceMappings.entrySet()) {
				marshaller.setNamespaceMapping(entry.getKey(), entry.getValue());
			}
		}
	}
1021064
protected SubjectLocality buildSubjectLocality(final Object assertion, final RequestAbstractType authnRequest,
                                                   final SamlRegisteredServiceServiceProviderMetadataFacade adaptor,
                                                   final String binding) throws SamlException {
        val subjectLocality = newSamlObject(SubjectLocality.class);
        val hostAddress = InetAddressUtils.getCasServerHostAddress(casProperties.getServer().getName());
        val issuer = SamlIdPUtils.getIssuerFromSamlObject(authnRequest);
        LOGGER.debug("Built subject locality address [{}] for the saml authentication statement prepped for [{}]", hostAddress, issuer);
        subjectLocality.setAddress(hostAddress);
        return subjectLocality;
    }
180260
public void setKeyspaceDefinition(KSMetaData ksm)
    {
        assert ksm != null;
        keyspaces.put(ksm.name, ksm);
    }
1089299
public void setSingleSignOn(HttpRequest request,
                                HttpResponse response,
                                Principal principal,
                                Credential credential)
    {
        
        String ssoID=null;
        
        synchronized(_ssoId2Principal)
        {
            // Create new SSO ID
            while (true)
            {
                ssoID = Long.toString(Math.abs(_random.nextLong()),
                                      30 + (int)(System.currentTimeMillis() % 7));
                if (!_ssoId2Principal.containsKey(ssoID))
                    break;
            }
            
            if(log.isDebugEnabled())log.debug("set ssoID="+ssoID);
            _ssoId2Principal.put(ssoID,principal);
            _ssoPrincipal2Credential.put(principal,credential);
            _ssoUsername2Id.put(principal.getName(),ssoID);
        }
        
        Cookie cookie = new Cookie(SSO_COOKIE_NAME, ssoID);
        cookie.setPath("/");
        response.addSetCookie(cookie);
    }
1232446
public void setSchemaSources(Source... s) {
        if (s != null) {
            sourceLocations = Arrays.copyOf(s, s.length);
        } else {
            sourceLocations = null;
        }
    }
843721
public void setSSECustomerKey(SSECustomerKey sseKey) {
        if (sseKey != null && this.sseAwsKeyManagementParams != null) {
            throw new IllegalArgumentException(
                "Either SSECustomerKey or SSEAwsKeyManagementParams must not be set at the same time.");
        }
        this.sseCustomerKey = sseKey;
    }
692814
public static void setSunIndentString (@Nonnull final Marshaller aMarshaller, @Nullable final String sIndentString)
  {
    final String sPropertyName = SUN_INDENT_STRING;
    _setProperty (aMarshaller, sPropertyName, sIndentString);
  }
458418
public WebServiceTemplateBuilder setMarshaller(Marshaller marshaller) {
		return new WebServiceTemplateBuilder(this.detectHttpMessageSender,
				this.interceptors, this.internalCustomizers, this.customizers,
				this.messageSenders, marshaller, this.unmarshaller,
				this.destinationProvider, this.transformerFactoryClass,
				this.messageFactory);
	}
522688
public void validate(ClientState state) throws RequestValidationException
    {
        ThriftValidation.validateKeyspaceNotSystem(name);

        // keyspace name
        if (!name.matches("\\w+"))
            throw new InvalidRequestException(String.format("\"%s\" is not a valid keyspace name", name));
        if (name.length() > Schema.NAME_LENGTH)
            throw new InvalidRequestException(String.format("Keyspace names shouldn't be more than %s characters long (got \"%s\")", Schema.NAME_LENGTH, name));

        attrs.validate();

        if (attrs.getReplicationStrategyClass() == null)
            throw new ConfigurationException("Missing mandatory replication strategy class");

        // The strategy is validated through KSMetaData.validate() in announceNewKeyspace below.
        // However, for backward compatibility with thrift, this doesn't validate unexpected options yet,
        // so doing proper validation here.
        AbstractReplicationStrategy.validateReplicationStrategy(name,
                                                                AbstractReplicationStrategy.getClass(attrs.getReplicationStrategyClass()),
                                                                StorageService.instance.getTokenMetadata(),
                                                                DatabaseDescriptor.getEndpointSnitch(),
                                                                attrs.getReplicationOptions());
    }
334447
@Override
    public void setCredential(Subject subject) throws CredentialException {
        Hashtable<String, ?> customProperties = getBasicAuthHashtableFromSubject(subject);
        try {
            // Hashtable with basic auth information, all properties must be there.
            if (customProperties != null && !customProperties.isEmpty() && customProperties.size() == 3) {
                String realm = getRealm(customProperties);
                String securityName = getSecurityName(customProperties);
                SerializableProtectedString password = getPassword(customProperties);
                setBasicAuthCredential(subject, realm, securityName, password);
            }
        } finally {
            removeBasicAuthHashtable(subject, customProperties);
        }
    }
873615
public void setSchemaFacet(java.util.Collection<SchemaFacet> schemaFacet) {
        if (schemaFacet == null) {
            this.schemaFacet = null;
            return;
        }

        this.schemaFacet = new java.util.ArrayList<SchemaFacet>(schemaFacet);
    }
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

    }
851819
@Override
	public final void setJMSDestination(Destination destination) throws JMSException
    {
    	assertDeserializationLevel(MessageSerializationLevel.FULL);
        this.destination = DestinationTools.asRef(destination);
    }
1360401
@Override
    public void createNamespace() {
        // Use a temporary, no-keyspace session
        try (DBConn dbConn = createAndConnectConn(null)) {
            synchronized (m_schemaLock) {
                if (!m_schemaMgr.keyspaceExists(dbConn, m_keyspace)) {
                    m_schemaMgr.createKeyspace(dbConn, m_keyspace);
                }
            }
        }
    }
925985
public void setPreferredCipherSC(String name) throws SshException {

		if (name == null)
			return;

		if (ciphersSC.contains(name)) {
			prefCipherSC = name;
			setCipherPreferredPositionSC(name, 0);
		} else {
			throw new SshException(name + " is not supported",
					SshException.UNSUPPORTED_ALGORITHM);
		}
	}