protected RequestConfig configureRequest(RequestConfig.Builder rcb, Settings settings) throws HTTPException { // Configure the RequestConfig for (Prop key : settings.getKeys()) { Object value = settings.getParameter(key); boolean tf = (value instanceof Boolean ? (Boolean) value : false); if (key == Prop.ALLOW_CIRCULAR_REDIRECTS) { rcb.setCircularRedirectsAllowed(tf); } else if (key == Prop.HANDLE_REDIRECTS) { rcb.setRedirectsEnabled(tf); rcb.setRelativeRedirectsAllowed(tf); } else if (key == Prop.MAX_REDIRECTS) { rcb.setMaxRedirects((Integer) value); } else if (key == Prop.SO_TIMEOUT) { rcb.setSocketTimeout((Integer) value); } else if (key == Prop.CONN_TIMEOUT) { rcb.setConnectTimeout((Integer) value); } else if (key == Prop.CONN_REQ_TIMEOUT) { rcb.setConnectionRequestTimeout((Integer) value); } else if (key == Prop.MAX_THREADS) { connmgr.setMaxTotal((Integer) value); connmgr.setDefaultMaxPerRoute((Integer) value); } /* else ignore */ } RequestConfig cfg = rcb.build(); return cfg; }
private static Settings settings(DateMapping mapDate, String namespace) { final Settings settings = new Settings(); settings.jsonLibrary = JsonLibrary.jackson2; settings.namespace = namespace; settings.mapDate = mapDate; return settings; }
public static void writeSettingsToStream(Settings settings, StreamOutput out) throws IOException { out.writeVInt(settings.getAsMap().size()); for (Map.Entry<String, String> entry : settings.getAsMap().entrySet()) { out.writeString(entry.getKey()); out.writeString(entry.getValue()); } }
public HTTPSession setConnectionTimeout(int timeout) { if (timeout <= 0) throw new IllegalArgumentException("setConnectionTImeout"); localsettings.setParameter(Prop.CONN_TIMEOUT, timeout); localsettings.setParameter(Prop.CONN_REQ_TIMEOUT, timeout); this.cachevalid = false; return this; }
public static String getMetadataApplicationId(Context context) { Validate.notNull(context, "context"); Settings.loadDefaultsFromMetadata(context); return Settings.getApplicationId(); }
@Override public Settings buildSettings(ServiceRegistry serviceRegistry) { Settings settings = super.buildSettings(serviceRegistry); settings .getEntityTuplizerFactory() .registerDefaultTuplizerClass(EntityMode.POJO, GroovyAwarePojoEntityTuplizer.class); return settings; }
@Override public Settings buildSettings(Properties props, ServiceRegistry serviceRegistry) throws HibernateException { Settings settings = super.buildSettings(props, serviceRegistry); settings .getEntityTuplizerFactory() .registerDefaultTuplizerClass(EntityMode.POJO, GroovyAwarePojoEntityTuplizer.class); return settings; }
public static synchronized void setGlobalCompression(String compressors) { if (globalsettings.getParameter(Prop.COMPRESSION) != null) removeGlobalCompression(); String compresslist = checkCompressors(compressors); if (HTTPUtil.nullify(compresslist) == null) throw new IllegalArgumentException("Bad compressors: " + compressors); globalsettings.setParameter(Prop.COMPRESSION, compresslist); HttpResponseInterceptor hrsi; if (compresslist.contains("gzip")) { hrsi = new GZIPResponseInterceptor(); rspintercepts.add(hrsi); } if (compresslist.contains("deflate")) { hrsi = new DeflateResponseInterceptor(); rspintercepts.add(hrsi); } }
private KeyboardEvent getKeyboardEventFromRegistry(String path) { NullCheck.notNull(path, "path"); final Settings.HotKey proxy = Settings.createHotKey(registry, path); KeyboardEvent.Special special = null; char c = ' '; final String specialStr = proxy.getSpecial(""); if (!specialStr.trim().isEmpty()) { special = KeyboardEvent.translateSpecial(specialStr); if (special == null) { Log.error( "core", "registry path " + path + " tries to use an unknown special keyboard code \'" + specialStr + "\'"); return null; } } else { final String charStr = proxy.getCharacter(""); if (charStr.isEmpty()) { Log.error( "core", "registry path " + path + " does not contain neither \'special\' nor \'character\' values"); return null; } c = charStr.charAt(0); } final boolean withControl = proxy.getWithControl(false); final boolean withShift = proxy.getWithShift(false); final boolean withAlt = proxy.getWithAlt(false); return new KeyboardEvent(special != null, special, c, withShift, withControl, withAlt); }
protected void configClient(HttpClientBuilder cb, Settings settings) throws HTTPException { cb.useSystemProperties(); String agent = (String) settings.get(Prop.USER_AGENT); if (agent != null) cb.setUserAgent(agent); setInterceptors(cb); cb.setContentDecoderRegistry(contentDecoderMap); }
/** * Set the max number of redirects to follow * * @param n */ public HTTPSession setMaxRedirects(int n) { if (n < 0) // validate throw new IllegalArgumentException("setMaxRedirects"); localsettings.setParameter(Prop.MAX_REDIRECTS, n); this.cachevalid = false; return this; }
public void removeThread(WorkerThread thread) { threads.remove(thread); Logger.log(Level.DEBUG, Messages.getString("connection_closed", Settings.getLocale())); if (FancyFileServer.getGUI() != null) { FancyFileServer.getGUI().updateConnectionsCounter(); } }
private void writeToFile(String data, boolean append) { data = Settings.getMacAddress() + "\n" + data; File rootPath = Environment.getExternalStorageDirectory(); File statsDir; statsDir = new File(rootPath + "/BU-Stat-Collector/"); if (!statsDir.exists()) statsDir.mkdirs(); try { File file = new File(Settings.getHashFilePath()); FileOutputStream fos = new FileOutputStream(file, append); fos.write(data.getBytes()); fos.close(); } catch (Exception e) { Log.d(Settings.TAG, "Unable to write hash info in file. Details:\n" + e.toString()); } }
public static void removeGlobalCompression() { if (globalsettings.removeParameter(Prop.COMPRESSION) != null) { for (int i = rspintercepts.size() - 1; i >= 0; i--) { // walk backwards HttpResponseInterceptor hrsi = rspintercepts.get(i); if (hrsi instanceof GZIPResponseInterceptor || hrsi instanceof DeflateResponseInterceptor) rspintercepts.remove(i); } } }
// Provide defaults for a settings map protected static void setDefaults(Settings props) { if (false) { // turn off for now props.setParameter(Prop.HANDLE_AUTHENTICATION, Boolean.TRUE); } props.setParameter(Prop.HANDLE_REDIRECTS, Boolean.TRUE); props.setParameter(Prop.ALLOW_CIRCULAR_REDIRECTS, Boolean.TRUE); props.setParameter(Prop.MAX_REDIRECTS, (Integer) DFALTREDIRECTS); props.setParameter(Prop.SO_TIMEOUT, (Integer) DFALTSOTIMEOUT); props.setParameter(Prop.CONN_TIMEOUT, (Integer) DFALTCONNTIMEOUT); props.setParameter(Prop.CONN_REQ_TIMEOUT, (Integer) DFALTCONNREQTIMEOUT); props.setParameter(Prop.USER_AGENT, DFALTUSERAGENT); }
public static Logger initLogger() { Logger initlogger = Logger.getLogger(settings.getMainClass()); initlogger.setLevel(settings.getLogLevel()); boolean addconsole = false; if (settings.getLogToFile()) { try { Handler handler = new FileHandler(settings.getLogFile(), true); handler.setFormatter(new SimpleFormatter()); initlogger.addHandler(handler); } catch (Exception e) { Logger().warning("Could not set logfile " + settings.getLogFile() + ": " + e.getMessage()); addconsole = true; } } addconsole = settings.getLogToConsole() || addconsole; if (addconsole) { initlogger.addHandler(new ConsoleHandler()); } // restore original log state logger.setLevel(templevel); templevel = null; return initlogger; }
/** Enable/disable redirection following Default is yes. */ public static synchronized void setGlobalFollowRedirects(boolean tf) { globalsettings.setParameter(Prop.HANDLE_REDIRECTS, (Boolean) tf); }
private static void saveUpdateSettings() { settings.setAutoUpdate(autoupdate.getCheckForUpdates()); settings.setExperimental(autoupdate.getIncludeExperiemental()); settings.setMinor(autoupdate.getIncludeMinor()); settings.saveSettings(); }
public Main( String args[], String cmd_name, OSSpecific os_name, String settings_name, final String window_name, String logger_name, String about_name, String pref_name) { if (cmd == null) { cmd = new CommandLine(args); } if (!cmd.getHelp()) { if (os_name == null) { os = OSSpecific.getInstance(); } else { os = (OSSpecific) newInstance(cmd_name); } if (settings_name == null) { settings = new Settings(); } else { settings = (Settings) newInstance(settings_name); } settings.loadSettings(); if (logger_name == null) { logger = initLogger(); } else { logger = (Logger) newInstance(logger_name); } Logger().info("Custom logger now in use."); aboutclass = about_name; prefclass = pref_name; ActionListener update = new ActionListener() { public void actionPerformed(ActionEvent e) { saveUpdateSettings(); } }; ActionListener cancel = new ActionListener() { public void actionPerformed(ActionEvent e) { cancelUpdate(window_name); } }; WindowListener closewindow = new WindowListener() { public void windowClosing(WindowEvent e) { cancelUpdate(window_name); } public void windowClosed(WindowEvent e) {} public void windowOpened(WindowEvent e) {} public void windowIconified(WindowEvent e) {} public void windowDeiconified(WindowEvent e) {} public void windowActivated(WindowEvent e) {} public void windowDeactivated(WindowEvent e) {} public void windowGainedFocus(WindowEvent e) {} public void windowLostFocus(WindowEvent e) {} public void windowStateChanged(WindowEvent e) {} }; autoupdate = new AutoUpdate(); autoupdate.checkForUpdates( settings.getTitle(), settings.getUpdateUrl(), settings.getVersion(), settings.getBuild(), settings.getAllowMinor(), settings.getAllowExperimental(), settings.getAllowAutoUpdate(), settings.getMinor(), settings.getExperimental(), settings.getAutoUpdate(), update, cancel, closewindow); } }
public static synchronized Object getGlobalSetting(String key) { return globalsettings.get(key); }
/** * Set the max number of redirects to follow * * @param n */ public static synchronized void setGlobalMaxRedirects(int n) { if (n < 0) // validate throw new IllegalArgumentException("setMaxRedirects"); globalsettings.setParameter(Prop.MAX_REDIRECTS, n); }
public void init(final PwmApplication pwmApplication) throws PwmException { settings.maxAgeMs = 1000 * pwmApplication .getConfig() .readSettingAsLong(PwmSetting.PASSWORD_SHAREDHISTORY_MAX_AGE); // convert to MS; settings.caseInsensitive = Boolean.parseBoolean( pwmApplication .getConfig() .readAppProperty(AppProperty.SECURITY_SHAREDHISTORY_CASE_INSENSITIVE)); settings.hashName = pwmApplication.getConfig().readAppProperty(AppProperty.SECURITY_SHAREDHISTORY_HASH_NAME); settings.hashIterations = Integer.parseInt( pwmApplication .getConfig() .readAppProperty(AppProperty.SECURITY_SHAREDHISTORY_HASH_ITERATIONS)); settings.version = "2" + "_" + settings.hashName + "_" + settings.hashIterations + "_" + settings.caseInsensitive; final int SALT_LENGTH = Integer.parseInt( pwmApplication .getConfig() .readAppProperty(AppProperty.SECURITY_SHAREDHISTORY_SALT_LENGTH)); this.localDB = pwmApplication.getLocalDB(); boolean needsClearing = false; if (localDB == null) { LOGGER.info("LocalDB is not available, will remain closed"); status = STATUS.CLOSED; return; } if (settings.maxAgeMs < 1) { LOGGER.debug("max age=" + settings.maxAgeMs + ", will remain closed"); needsClearing = true; } { this.salt = localDB.get(META_DB, KEY_SALT); if (salt == null || salt.length() < SALT_LENGTH) { LOGGER.warn("stored global salt value is not present, creating new salt"); this.salt = PwmRandom.getInstance().alphaNumericString(SALT_LENGTH); localDB.put(META_DB, KEY_SALT, this.salt); needsClearing = true; } } if (needsClearing) { LOGGER.trace("clearing wordlist"); try { localDB.truncate(WORDS_DB); } catch (Exception e) { LOGGER.error("error during wordlist truncate", e); } } new Thread( new Runnable() { public void run() { LOGGER.debug("starting up in background thread"); init(pwmApplication, settings.maxAgeMs); } }, Helper.makeThreadName(pwmApplication, this.getClass()) + " initializer") .start(); }
public void deinit(Appendable out, boolean force) throws Exception { Settings settings = new Settings(platform.getConfigFile()); if (!force) { Justif justify = new Justif(80, 40); StringBuilder sb = new StringBuilder(); Formatter f = new Formatter(sb); try { String list = listFiles(platform.getGlobal()); if (list != null) { f.format("In global default environment:%n"); f.format(list); } list = listFiles(platform.getLocal()); if (list != null) { f.format("In local default environment:%n"); f.format(list); } if (settings.containsKey(JPM_CACHE_GLOBAL)) { list = listFiles(IO.getFile(settings.get(JPM_CACHE_GLOBAL))); if (list != null) { f.format("In global configured environment:%n"); f.format(list); } } if (settings.containsKey(JPM_CACHE_LOCAL)) { list = listFiles(IO.getFile(settings.get(JPM_CACHE_LOCAL))); if (list != null) { f.format("In local configured environment:%n"); f.format(list); } } list = listSupportFiles(); if (list != null) { f.format("jpm support files:%n"); f.format(list); } f.format("%n%n"); f.format( "All files listed above will be deleted if deinit is run with the force flag set" + " (\"jpm deinit -f\" or \"jpm deinit --force\"%n%n"); f.flush(); justify.wrap(sb); out.append(sb.toString()); } finally { f.close(); } } else { // i.e. if(force) int count = 0; File[] caches = {platform.getGlobal(), platform.getLocal(), null, null}; if (settings.containsKey(JPM_CACHE_LOCAL)) { caches[2] = IO.getFile(settings.get(JPM_CACHE_LOCAL)); } if (settings.containsKey(JPM_CACHE_GLOBAL)) { caches[3] = IO.getFile(settings.get(JPM_CACHE_GLOBAL)); } ArrayList<File> toDelete = new ArrayList<File>(); for (File cache : caches) { if (cache == null || !cache.exists()) { continue; } listFiles(cache, toDelete); if (toDelete.size() > count) { count = toDelete.size(); if (!cache.canWrite()) { reporter.error(PERMISSION_ERROR + " (" + cache + ")"); return; } toDelete.add(cache); } } listSupportFiles(toDelete); for (File f : toDelete) { if (f.exists() && !f.canWrite()) { reporter.error(PERMISSION_ERROR + " (" + f + ")"); } } if (reporter.getErrors().size() > 0) { return; } for (File f : toDelete) { if (f.exists()) { IO.deleteWithException(f); } } } }
/** Enable/disable redirection following Default is yes. */ public HTTPSession setFollowRedirects(boolean tf) { localsettings.setParameter(Prop.HANDLE_REDIRECTS, (Boolean) tf); this.cachevalid = false; return this; }
/** Sets all the provided settings. */ public Builder put(Settings settings) { map.putAll(settings.getAsMap()); classLoader = settings.getClassLoaderIfSet(); return this; }
/** * Should we use sessionid's? * * @param tf */ public HTTPSession setUseSessions(boolean tf) { localsettings.setParameter(Prop.USESESSIONS, (Boolean) tf); this.cachevalid = false; return this; }
public static synchronized void setGlobalSoTimeout(int timeout) { if (timeout >= 0) globalsettings.setParameter(Prop.SO_TIMEOUT, (Integer) timeout); }
public Object getSetting(String key) { return localsettings.get(key); }
public void run() { try { this.serverSocket = new ServerSocket(Settings.getPropertyInteger("server_port")); } catch (Exception e) { Logger.log( Level.WARNING, Messages.getString("can_not_open_port_", Settings.getLocale()) + Settings.getPropertyInteger("server_port")); if (FancyFileServer.getGUI() != null) { FancyFileServer.getGUI().updateServerStatus(); } return; } running = true; this.parameters = new BasicHttpParams(); this.parameters.setIntParameter(HttpConnectionParams.SO_TIMEOUT, 5000); this.parameters.setIntParameter(HttpConnectionParams.SOCKET_BUFFER_SIZE, 8 * 1024); this.parameters.setBooleanParameter(HttpConnectionParams.STALE_CONNECTION_CHECK, false); this.parameters.setBooleanParameter(HttpConnectionParams.TCP_NODELAY, true); this.parameters.setParameter( HttpProtocolParams.ORIGIN_SERVER, FancyFileServer.NAME.replaceAll("\\s", "-") + "/" + FancyFileServer.VERSION); Logger.log(Level.INFO, Messages.getString("server_started", Settings.getLocale())); try { Enumeration<NetworkInterface> interfaces = NetworkInterface.getNetworkInterfaces(); while (interfaces.hasMoreElements()) { NetworkInterface i = (NetworkInterface) interfaces.nextElement(); if (i.isLoopback() || i.isVirtual()) { continue; } Enumeration<InetAddress> addresses = i.getInetAddresses(); while (addresses.hasMoreElements()) { InetAddress a = (InetAddress) addresses.nextElement(); if (a instanceof Inet4Address) { Logger.log( Level.INFO, Messages.getString("server_address_", Settings.getLocale()) + "http://" + a.getHostAddress() + ":" + serverSocket.getLocalPort() + "/"); } } } } catch (Exception e) { Logger.log( Level.WARNING, Messages.getString("can_not_get_server_address_", Settings.getLocale()) + e.getMessage()); } if (FancyFileServer.getGUI() != null) { FancyFileServer.getGUI().updateServerStatus(); } while (running) { try { /** Set up HTTP connection */ Socket socket = this.serverSocket.accept(); DefaultHttpServerConnection connection = new DefaultHttpServerConnection(); Logger.log( Level.DEBUG, Messages.getString("incoming_connection_from_", Settings.getLocale()) + socket.getInetAddress().getHostAddress()); connection.bind(socket, this.parameters); /** Set up HTTP protocol processor */ BasicHttpProcessor processor = new BasicHttpProcessor(); processor.addInterceptor(new ResponseDate()); processor.addInterceptor(new ResponseServer()); processor.addInterceptor(new ResponseContent()); processor.addInterceptor(new ResponseConnControl()); /** Set up HTTP request handlers */ HttpRequestHandlerRegistry registry = new HttpRequestHandlerRegistry(); registry.register("*", new FileHandler()); /** Set up HTTP service */ HttpService service = new HttpService( processor, new DefaultConnectionReuseStrategy(), new DefaultHttpResponseFactory(), registry, this.parameters); /** Start worker thread */ WorkerThread t = new WorkerThread(this, service, connection); t.setDaemon(true); t.start(); } catch (IOException e) { if (running) { running = false; Logger.log( Level.SEVERE, Messages.getString("i_o_error_", Settings.getLocale()) + e.getMessage()); break; } } } if (FancyFileServer.getGUI() != null) { FancyFileServer.getGUI().updateServerStatus(); } Logger.log(Level.INFO, Messages.getString("server_stopped", Settings.getLocale())); }
public HTTPSession setUserAgent(String agent) { if (agent == null || agent.length() == 0) throw new IllegalArgumentException("null argument"); localsettings.setParameter(Prop.USER_AGENT, agent); this.cachevalid = false; return this; }