Apply log file details to {@code LOG_PATH} and {@code LOG_FILE} map entries.
@param properties the properties to apply to
330893
public void applyTo(Properties properties) {
		put(properties, LoggingSystemProperties.LOG_PATH, this.path);
		put(properties, LoggingSystemProperties.LOG_FILE, toString());
	}
585047
@Override
    public LogProperties logProperties() {
        if (tc.isDebugEnabled())
            Tr.debug(tc, "logProperties", _customLogProperties);
        return _customLogProperties;
    }
1065986
public void storeProperties(Map<String, String> properties) throws IOException {
        Properties props = new Properties();
        properties.forEach(props::setProperty);
        try (FileOutputStream out = new FileOutputStream(getPropertiesFile())) {
            props.store(out, "");
        }
    }
881064
public void setProperties(Properties properties) {
		sessionTimeout = Integer.valueOf(properties.getProperty("session_timeout", "" + sessionTimeout));
		System.out.println(new LogEntry("session timeout set to " + sessionTimeout + " (sec)"));
		defaultAdminPassword = properties.getProperty("default_admin_password", defaultAdminPassword);
	}
544737
public void setProperties(Map<String, Object> properties)
    {
        if (this.getParentRecordOwner() != null)
            this.getParentRecordOwner().setProperties(properties);
    }
416770
public void registerPropertyExclusions( Class target, String[] properties ) {
      if( target != null && properties != null && properties.length > 0 ) {
         Set set = (Set) exclusionMap.get( target );
         if( set == null ) {
            set = new HashSet();
            exclusionMap.put( target, set );
         }
         for( int i = 0; i < properties.length; i++ ) {
            if( !set.contains( properties[i] ) ) {
               set.add( properties[i] );
            }
         }
      }
   }
299240
public static void storeProperties(Properties p, File file) throws IOException {
        FileOutputStream fos = new FileOutputStream(file);
        try {
            p.store(fos,"");
        } finally {
            ArchiveUtils.closeQuietly(fos);
        }
    }
974794
@Activate
    protected void activate(Map<String, Object> properties) {
        final String methodName = "activate";
        final boolean trace = TraceComponent.isAnyTracingEnabled();
        if (trace && tc.isEntryEnabled())
            Tr.entry(tc, methodName, "Entry Count: " + ++JDBCMBeanRuntime.counterActivate);
        if (trace && tc.isEventEnabled())
            Tr.event(tc, className + methodName, properties);
        if (trace && tc.isEntryEnabled())
            Tr.exit(tc, methodName, "Normal Exit");

    }
1212887
public static void runMahoutRecommenders(final Set<String> paths, final Properties properties) {
        for (AbstractRunner<Long, Long> rec : instantiateMahoutRecommenders(paths, properties)) {
            RecommendationRunner.run(rec);
        }
    }
869237
public static Properties readPropertiesFileQuietly( File file, Logger logger ) {

		Properties result = new Properties();
		try {
			if( file != null && file.exists())
				result = readPropertiesFile( file );

		} catch( Exception e ) {
			logger.severe( "Properties file " + file + " could not be read." );
			logException( logger, e );
		}

		return result;
	}
488764
public void doConfigure(Map<String, Object> properties) throws IOException {
		SettingsBuildingRequest request = new DefaultSettingsBuildingRequest();

		File mavenSettingsFile = null;
		if(properties.containsKey(MAVEN_SETTINS_PATH_PROPERTY)) {
			mavenSettingsFile = new File(
					properties.get(MAVEN_SETTINS_PATH_PROPERTY).toString()
			);
		} else {
			mavenSettingsFile = new File(DEFAULT_MAVEN_SETTINGS_PATH);
		}
		if(mavenSettingsFile.exists()) {
			request.setUserSettingsFile(mavenSettingsFile);
			resolver = Maven.configureResolver().fromFile(mavenSettingsFile);

			if(supportLogger.isDebugEnabled()) supportLogger.debug(Logs.LOG_01,
					ansiString(GREEN, mavenSettingsFile.getCanonicalPath())
			);
		} else {
			resolver = Maven.resolver();

			if(supportLogger.isWarnEnabled()) supportLogger.warn(Logs.LOG_02,
					ansiString(GREEN, mavenSettingsFile.getCanonicalPath())
			);
		}

		if(supportLogger.isTraceEnabled()) supportLogger.trace(Logs.LOG_03,
				ansiString(GREEN, ObjectUtils.toStringBuilder(request))
		);

		settings = new MavenSettingsBuilder().buildSettings(request);

		if(supportLogger.isTraceEnabled()) {
			supportLogger.trace(Logs.LOG_04,
					ansiString(GREEN, ObjectUtils.toStringBuilder(settings))
			);
		} else if(supportLogger.isDebugEnabled()) {
			supportLogger.trace(Logs.LOG_05,
					ansiString(GREEN, settings.getLocalRepository())
			);
		}

//		setActive(true);
	}
43388
public void setProperties( Map<String, Object> properties )
    {
        Introspector introspector = new Introspector( target.getClass(), new PropertyComparator() );
        for (Map.Entry<String,Object> property : properties.entrySet())
        {
            Method setter = introspector.getSetter( property.getKey() );
            if (setter != null) invoke( setter, property.getValue() );
        }
    }
1335079
private void buildPropertiesFile(String path) throws IOException {
    Properties properties = new Properties();
    properties.put(MetaInf.PACKAGE_FORMAT_VERSION, Integer.toString(MetaInf.FORMAT_VERSION_2));
    properties.put(PackageProperties.NAME_REQUIRES_ROOT, Boolean.toString(false));

    for (Map.Entry<String, Object> entry : metadata.getVars().entrySet()) {
      String value = Objects.toString(entry.getValue());
      if (StringUtils.isNotEmpty(value)) {
        properties.put(entry.getKey(), value);
      }
    }

    zip.putNextEntry(new ZipEntry(path));
    try {
      properties.storeToXML(zip, null);
    }
    finally {
      zip.closeEntry();
    }
  }
1243730
private void addPropertiesFromFile(final SystemProperties config, final ServletContext context) {
        String fileLocation = StringUtils.replaceVariables(config.getFile(), new HashMap<String, Object>(), true);
        InputStream inStream = null;
        try {
            inStream = getStreamForLocation(fileLocation, context);
            Properties propsFromFile = new Properties();
            propsFromFile.load(inStream);
            for (String prop : propsFromFile.stringPropertyNames()) {
                String propertyValue = propsFromFile.getProperty(prop);
                if (propertyValue != null && (config.isOverrideProperties() || (System.getProperty(prop) == null))) {
                    System.setProperty(prop, propertyValue);
                }
            }
        } catch (FileNotFoundException e) {
            if (!config.isIgnoreMissingFile()) { 
                throw new IllegalStateException("Could not find properties file: " + fileLocation, e);
            }
        } catch (IOException e) {
            if (!config.isIgnoreMissingFile()) { 
                throw new IllegalStateException("Error occurred when reading properties file: " + fileLocation, e);
            }
        } finally {
            if (inStream != null) {
                try {
                    inStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
915348
@SneakyThrows
   public static void setProperty(String name, String value) {
      getInstance().properties.put(name, value);
      if (name.toLowerCase().endsWith(".level")) {
         String className = name.substring(0, name.length() - ".level".length());
         LogManager.getLogManager().setLevel(className, Level.parse(value.trim().toUpperCase()));
      }
      if (name.equals("com.davidbracewell.logging.logfile")) {
         LogManager.addFileHandler(value);
      }
      if (name.toLowerCase().startsWith(SYSTEM_PROPERTY)) {
         String systemSetting = name.substring(SYSTEM_PROPERTY.length());
         System.setProperty(systemSetting, value);
      }
      log.finest("Setting property {0} to value of {1}", name, value);
   }
706077
@Override
    public void updateProperties(Dictionary<String, Object> properties) throws IOException {
        lock.lock();
        try {
            doUpdateProperties(properties);
        } finally {
            lock.unlock();
        }
    }
889147
protected void logJobProperties() {
    if (this.jobProps != null &&
        this.jobProps.getBoolean(JOB_DUMP_PROPERTIES_IN_LOG, false)) {
      try {
        final Map<String, String> flattenedProps = this.jobProps.getFlattened();
        this.info("******   Job properties   ******");
        this.info(String.format("- Note : value is masked if property name ends with '%s'.",
            SENSITIVE_JOB_PROP_NAME_SUFFIX));
        for (final Map.Entry<String, String> entry : flattenedProps.entrySet()) {
          final String key = entry.getKey();
          final String value = key.endsWith(SENSITIVE_JOB_PROP_NAME_SUFFIX) ?
              SENSITIVE_JOB_PROP_VALUE_PLACEHOLDER :
              entry.getValue();
          this.info(String.format("%s=%s", key, value));
        }
        this.info("****** End Job properties  ******");
      } catch (final Exception ex) {
        this.error("failed to log job properties ", ex);
      }
    }
  }