Load the customer Properties to Configurations.

@param props
the customer Properties.
346074
public static void loadCustomerProperties(Properties props){
        for(Entry<Object, Object> entry : props.entrySet()){
            setProperty((String)entry.getKey(), entry.getValue());
        }
    }
777108
@SneakyThrows
    public static ClientConfiguration buildClientConfiguration(final BaseAmazonWebServicesProperties props) {
        val cfg = new ClientConfiguration();
        cfg.setConnectionTimeout(props.getConnectionTimeout());
        cfg.setMaxConnections(props.getMaxConnections());
        cfg.setRequestTimeout(props.getRequestTimeout());
        cfg.setSocketTimeout(props.getSocketTimeout());
        cfg.setUseGzip(props.isUseGzip());
        cfg.setUseReaper(props.isUseReaper());
        cfg.setUseThrottleRetries(props.isUseThrottleRetries());
        cfg.setUseTcpKeepAlive(props.isUseTcpKeepAlive());
        cfg.setProtocol(Protocol.valueOf(props.getProtocol().toUpperCase()));
        cfg.setClientExecutionTimeout(props.getClientExecutionTimeout());
        if (props.getMaxErrorRetry() > 0) {
            cfg.setMaxErrorRetry(props.getMaxErrorRetry());
        }
        cfg.setProxyHost(props.getProxyHost());
        cfg.setProxyPassword(props.getProxyPassword());
        if (props.getProxyPort() > 0) {
            cfg.setProxyPort(props.getProxyPort());
        }
        cfg.setProxyUsername(props.getProxyUsername());
        cfg.setCacheResponseMetadata(props.isCacheResponseMetadata());

        if (StringUtils.isNotBlank(props.getLocalAddress())) {
            LOGGER.trace("Creating DynamoDb client local address [{}]", props.getLocalAddress());
            cfg.setLocalAddress(InetAddress.getByName(props.getLocalAddress()));
        }

        return cfg;
    }
16614
public static void setProperties(SystemStoreClient<String, String> versionStore,
                                     Versioned<Properties> props) {
        if(props == null || props.getValue() == null) {
            logger.info("Ignoring set for empty properties");
            return;
        }

        try {
            String versionString = getPropertiesString(props.getValue());
            Versioned<String> versionedString = new Versioned<String>(versionString,
                                                                      props.getVersion());
            versionStore.putSysStore(SystemStoreConstants.VERSIONS_METADATA_KEY, versionedString);
        } catch(Exception e) {
            logger.info("Got exception in setting properties : ", e);
        }
    }
1048158
protected static void loadPropertiesOverrides (
        PropRecord prec, Map<String,PropRecord> records, Map<String,PropRecord> applied,
        ClassLoader loader, Properties target)
        throws IOException
    {
        if (applied.containsKey(prec._package)) {
            return;
        }

        // first load up properties from all of our parent nodes
        if (prec._overrides != null) {
            for (String override : prec._overrides) {
                PropRecord parent = records.get(override);
                loadPropertiesOverrides(parent, records, applied, loader, target);
            }
        }

        // now apply our properties values
        InputStream in = prec.sourceURL.openStream();
        target.load(in);
        in.close();
        applied.put(prec._package, prec);
    }
1051695
function(props) {
      if (typeof props !== 'object') {
        throw new Error('_configureItems called with invalid props');
      }
      // not initialized yet
      if (!this._items) {
        return;
      }
      this._items.configure({
        where: bindIfFn(props.where, this),
        filter: bindIfFn(props.filter, this),
        limit: bindIfFn(props.limit, this),
        offset: bindIfFn(props.offset, this),
        comparator: bindIfFn(props.sort, this)
      }, true);
    }
540076
@SuppressWarnings("rawtypes")
   public static HikariConfig loadConfiguration(Map props)
   {
      Properties hikariProps = new Properties();
      copyProperty(AvailableSettings.ISOLATION, props, "transactionIsolation", hikariProps);
      copyProperty(AvailableSettings.AUTOCOMMIT, props, "autoCommit", hikariProps);
      copyProperty(AvailableSettings.DRIVER, props, "driverClassName", hikariProps);
      copyProperty(AvailableSettings.URL, props, "jdbcUrl", hikariProps);
      copyProperty(AvailableSettings.USER, props, "username", hikariProps);
      copyProperty(AvailableSettings.PASS, props, "password", hikariProps);

      for (Object keyo : props.keySet()) {
         String key = (String) keyo;
         if (key.startsWith(CONFIG_PREFIX)) {
            hikariProps.setProperty(key.substring(CONFIG_PREFIX.length()), (String) props.get(key));
         }
      }

      return new HikariConfig(hikariProps);
   }
495615
private void loadProperties(String propFileName) {
		if (propFileName != null) {
			loadProperties(getClass().getResourceAsStream(propFileName), propFileName);
		}
	}
443787
private static void setProperties(GenericApplicationContext newContext, Properties properties) {
        PropertiesPropertySource pps = new PropertiesPropertySource("external-props", properties);
        newContext.getEnvironment().getPropertySources().addFirst(pps);
    }
506165
public void bind(T service, Map<String, Object> props) {
    synchronized (serviceMap) {
      serviceMap.put(ServiceUtil.getComparableForServiceRanking(props), service);
      updateSortedServices();
    }
  }
1069019
@Override
    public void configure(Map props) {
        super.configure(props);
        LOGGER.debug("Hibernate switched to using FlexyPoolDataSource");
        Properties overridingProperties = new Properties();
        for(Map.Entry<String, Object> propsEntry : ((Map<String, Object>) props).entrySet()) {
            if(propsEntry.getKey().startsWith( FLEXY_POOL_PROPERTY_PREFIX ) &&
                propsEntry.getValue() instanceof String) {
                overridingProperties.setProperty(
                    propsEntry.getKey(),
                    (String) propsEntry.getValue()
                );
            }
        }
        flexyPoolDataSource = new FlexyPoolDataSource<DataSource>(getDataSource(), overridingProperties);
    }
384098
public synchronized void reconfigure(Properties props) {
        // First isolate any property that is different from the immutable
        // set of original initialization properties
        Properties newOverrideProps = new Properties();
        for (Entry<Object, Object> prop : props.entrySet()) {
            if (isLog4JProperty(prop.getKey().toString())) {
                Object initialValue = initialProps.get(prop.getKey());
                if (initialValue == null || !initialValue.equals(prop.getValue())) {
                    newOverrideProps.put(prop.getKey(), prop.getValue());
                }
            }
        }
        
        // Compare against our cached set of override
        if (!overrideProps.equals(newOverrideProps)) {
            this.overrideProps.clear();
            this.overrideProps.putAll(newOverrideProps);
            reConfigureAsynchronously();
        }
    }
980194
public void setProjectProperties(final Properties properties) {
        generateProjectPropertiesFile(getName(), propertyFile, true, properties, false, null, false);
        loadProperties();
    }
1017358
public static ConfigurationLoader from(final Properties props) throws IOException {
        return new ConfigurationLoader(new Function<String, String>() {
            public String apply(String from) {
                return props.getProperty(from);
            }
        });
    }
1041878
public void init(final Map<String, Map<String, DataSourceConfiguration>> dataSourceConfigurationMap,
                     final Map<String, RuleConfiguration> schemaRuleMap, final Authentication authentication, final Properties props) {
        for (Entry<String, Map<String, DataSourceConfiguration>> entry : dataSourceConfigurationMap.entrySet()) {
            configService.persistConfiguration(entry.getKey(), dataSourceConfigurationMap.get(entry.getKey()), schemaRuleMap.get(entry.getKey()), authentication, props, isOverwrite);
        }
        stateService.persistInstanceOnline();
        stateService.persistDataSourcesNode();
        listenerManager.initListeners();
    }
930150
static void setBeanProperties(Object object, Properties props)
            throws SQLException {

        if (props != null) {
            Enumeration<?> enumeration = props.keys();
            while (enumeration.hasMoreElements()) {
                String name = (String) enumeration.nextElement();
                setProperty(object, name, props.getProperty(name));
            }
        }
    }
342521
private void loadProperties(File propFile) {
		if (propFile == null) {
			return;
		}
		try {
			loadProperties(new FileInputStream(propFile), propFile.getAbsolutePath());
		}
		catch (FileNotFoundException e) {
			Console.warn("Unable to find properties file ["+propFile.getAbsolutePath()+"].");
		}
	}
955553
public void init(final Authentication authentication, final Properties props) {
        this.authentication = authentication;
        shardingProperties = new ShardingProperties(props);
    }