Java JConfig类代码示例

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * Gets the logger.
 * 
 * @param c
 *          the c
 * @return the logger
 */
public static Logger getLogger(Class<?> c) {
	if (triggerConfigInit && c != JConfig.class) {
		/*
		 * This is needed because of the timing. JConfig reloads the logger
		 * properties and causes all prior initialization to be lost. So we
		 * basically trigger the JConfig initialization on the first getLogger
		 * request. If JConfig has already been initialized some other means, it
		 * won't do it again, but since we don't know we call its init method, the
		 * first time we do anyway. JConfig also preserves its own level, so
		 */
		triggerConfigInit = false;
		JConfig.init();
	}

	return getLogger(c.getName());
}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * Sets the level.
 * 
 * @param newLevel
 *          the new level
 * @throws SecurityException
 *           the security exception
 * @see java.util.logging.Logger#setLevel(java.util.logging.Level)
 */
@Override
public void setLevel(Level newLevel) throws SecurityException {
	super.setLevel(newLevel);

	if (triggerConfigInit) {
		triggerConfigInit = false;
		JConfig.init();
	}
}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * Checks for cache file.
 * 
 * @return true, if successful
 */
protected boolean hasCacheFile() {
	File file;
	try {
		file = JConfig.getFile(this.name, PROPERTY_RESOLVER_FILE_SEARCH_PATH);
	} catch (IOException e) {
		return false;
	}
	return file != null && file.canRead() && file.length() > 0;
}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * Inits the properties.
 */
private void initProperties() {
	JConfig.addListener(this,
			String.format(PROPERTY_POSITIVE_TIMEOUT, ""),
			DEFAULT_POSITIVE_TIMEOUT_IN_MILLIS);
	JConfig.addListener(this,
			String.format(PROPERTY_NEGATIVE_TIMEOUT, ""),
			DEFAULT_NEGATIVE_TIMEOUT_IN_MILLIS);
	JConfig.addListener(this,
			String.format(PROPERTY_SAVE_CACHE, ""),
			DEFAULT_SAVE_CACHE);
	JConfig.addListener(this,
			String.format(PROPERTY_MAX_ENTRIES, ""),
			DEFAULT_MAX_ENTRIES);
	JConfig.addListener(this,
			String.format(PROPERTY_BACKOFF, ""),
			DEFAULT_BACKOFF);
	JConfig.addListener(this,
			String.format(PROPERTY_MKDIR_HOME, ""),
			DEFAULT_MKDIR_HOME);

	/*
	 * we don't specify a default for these, as the default would cause the
	 * parent value to be always overriden. A null default will not trigger a
	 * secondary property update and thus leaving everything at the parent's
	 * default defined above.
	 */
	final String n = this.name + ".";
	JConfig
			.addListener(this, String.format(PROPERTY_POSITIVE_TIMEOUT, n), null);
	JConfig
			.addListener(this, String.format(PROPERTY_NEGATIVE_TIMEOUT, n), null);
	JConfig.addListener(this, String.format(PROPERTY_SAVE_CACHE, n), null);
	JConfig.addListener(this, String.format(PROPERTY_MAX_ENTRIES, n), null);
	JConfig.addListener(this,
			String.format(PROPERTY_BACKOFF, this.name + "."),
			null);
}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * Load cache entries using default mechanism.
 * 
 * @return number of cache entries read
 * @throws IOException
 *           Signals that an I/O exception has occurred.
 */
public int loadCache() throws IOException {

	URL url = JConfig.getURL(this.name, RESOLVER_SEARCH_PATH_PROPERTY);
	if (url == null) {
		logger.fine("cache file " + name + " not found");
		return 0;
	}

	logger.finer("loading cache file " + url.toString());
	return loadCache(new BufferedReader(new InputStreamReader(url.openStream())));
}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * Test http formatting with resolve address enabled.
 * 
 * @throws IOException
 *           Signals that an I/O exception has occurred.
 */
public void testHttpFormattingWithResolveAddressEnabled() throws IOException {
	JLogger.getLogger(JConfig.class).setLevel(Level.FINE);

	JLogger.getLogger(Resolver.class.getPackage()).setLevel(Level.FINER);

	JFormatter out = new TextFormatter(OUT);
	out.setResolveAddresses(true);

	PcapPacket packet = TestUtils.getPcapPacket("tests/test-http-jpeg.pcap", 5);

	Ip4 ip = new Ip4();
	Ethernet eth = new Ethernet();
	if (packet.hasHeader(eth)) {
		out.format(eth);
	}
	if (packet.hasHeader(ip)) {
		// out.format(ip);
		out.format(ip);
		System.out.println();
	}

	// out.format(packet);

	// if (true && packet.hasHeader(http)) {
	// Map<String, Http.Entry> map = http.headerFields();
	//
	// for (Entry e : map.values()) {
	// System.out.println(e.toString());
	// }
	// }

	JRegistry.shutdown();
}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * _test cache search path.
 * 
 * @throws IOException
 *           Signals that an I/O exception has occurred.
 */
public void _testCacheSearchPath() throws IOException {
	logger.setLevel(Level.FINER);

	assertNotNull("failed to locate IP resolver file", JConfig.getInputStream(
	    "IP", Resolver.RESOLVER_SEARCH_PATH_PROPERTY));

}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * _test resource search path oui txt file.
 * 
 * @throws IOException
 *           Signals that an I/O exception has occurred.
 */
public void _testResourceSearchPathOuiTxtFile() throws IOException {
	logger.setLevel(Level.FINER);

	assertNotNull("failed to locate oui.txt resource file", JConfig
	    .getResourceInputStream("oui.txt"));
}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * _test resource search path oui txt url.
 * 
 * @throws IOException
 *           Signals that an I/O exception has occurred.
 */
public void _testResourceSearchPathOuiTxtURL() throws IOException {
	logger.setLevel(Level.FINER);

	URL url = null;
	assertNotNull("failed to locate oui.txt resource file", url =
	    JConfig.getResourceURL("oui.txt"));

	System.out.println(url);

}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * Test search path from property.
 * 
 * @throws IOException
 *           Signals that an I/O exception has occurred.
 */
public void testSearchPathFromProperty() throws IOException {
	logger.setLevel(Level.FINER);

	for (SearchPath p : JConfig
	    .createSearchPath(Resolver.RESOLVER_SEARCH_PATH_PROPERTY)) {

		System.out.println(p.toString());
	}
}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * Initializes the resolver by first checking if there are any cached entries,
 * if none, it reads the compressed oui database supplied with jNetPcap in the
 * resource directory.
 */
@Override
public void initializeIfNeeded() {
	if (initialized == false && hasCacheFile() == false) {
		initialized = true;

		setCacheCapacity(13000); // There are over 12,000 entries in the db

		super.initializeIfNeeded(); // Allow the baseclass to prep cache

		setPositiveTimeout(INFINITE_TIMEOUT); // Never
		setNegativeTimeout(0);

		/*
		 * First look for compressed OUI database.
		 */

		try {
			URL url = JConfig.getResourceURL(RESOURCE_COMPRESSED_OUI_DATABASE);
			if (url != null) {
				logger
						.fine("loading compressed database file from " + url.toString());
				readOuisFromCompressedIEEEDb(RESOURCE_COMPRESSED_OUI_DATABASE);
				return;
			}

			boolean download =
					Boolean.parseBoolean(JConfig.getProperty(PROPERTY_OUI_DB_DOWNLOAD,
							DEFAULT_OUI_DB_DOWNLOAD));
			String u = JConfig.getProperty(PROPERTY_OUI_DB_URL);
			if (u != null && download) {
				url = new URL(u);
				logger.fine("loading remote database " + url.toString());
				loadCache(url);
				return;
			}
		} catch (IOException e) {
			logger.log(Level.WARNING, "error while reading database", e);
		}
	} else {
		super.initializeIfNeeded();
	}
}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * Save the cache using default mechanism, if set.
 * 
 * @return number of cache entries saved
 * @throws IOException
 *           Signals that an I/O exception has occurred.
 */
public int saveCache() throws IOException {
	timeoutCache();

	if (saveCache == false || isModified == false || timeoutQueue.isEmpty()) {
		return 0;
	}

	URL url = JConfig.getURL(this.name, RESOLVER_SEARCH_PATH_PROPERTY);

	if (url == null) {
		logger.fine("cache file " + name + " not found");

		File dir = JConfig.getDir(PROPERTY_RESOLVER_HOME_SEARCH_PATH);
		if (dir == null) {
			logger.fine("cache directory not found");

			if (mkdirHome == true) {

				logger.fine("attempting to create cache directory using property "
						+ PROPERTY_RESOLVER_HOME);
				dir = JConfig.createDir(PROPERTY_RESOLVER_HOME, DEFAULT_HOME);
				if (dir == null) {
					return 0;
				}
			} else {
				logger.finer("property resolver.home.mkdir set to false, giving up");
				return 0;
			}
		}
		url = new File(dir, filename()).toURI().toURL();
	}

	logger.finer("saving cache " + url.toString());

	int count =
			saveCache(new PrintWriter(new OutputStreamWriter(new FileOutputStream(
					url.getFile()))));
	if (count == 0) {
		throw new IllegalStateException("Saved empty cache");
	}

	return count;
}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * Sets the when failed to resolve to a name, store the failure information in
 * cache and set the negative hit timeout.
 * 
 * @param negativeTimeout
 *          the new when failed to resolve to a name, store the failure
 *          information in cache and set the negative hit timeout
 */
public final void setNegativeTimeout(long negativeTimeout) {
	JConfig.setProperty(String.format(PROPERTY_NEGATIVE_TIMEOUT, this.name
			+ "."),
			Long.toString(negativeTimeout));
}
 

import org.jnetpcap.util.config.JConfig; //导入依赖的package包/类
/**
 * Sets the resolved to a name.
 * 
 * @param positiveTimeout
 *          the new resolved to a name
 */
public final void setPositiveTimeout(long positiveTimeout) {
	JConfig.setProperty(String.format(PROPERTY_POSITIVE_TIMEOUT, this.name
			+ "."),
			Long.toString(positiveTimeout));
}