/** @see java.net.URLStreamHandler#openConnection(URL) */ protected URLConnection openConnection(URL u) throws IOException { try { URL otherURL = new URL(u.getFile()); String host = otherURL.getHost(); String protocol = otherURL.getProtocol(); int port = otherURL.getPort(); String file = otherURL.getFile(); String query = otherURL.getQuery(); // System.out.println("Trying to load: " + u.toExternalForm()); String internalFile = null; if (file.indexOf("!/") != -1) { internalFile = file.substring(file.indexOf("!/") + 2); file = file.substring(0, file.indexOf("!/")); } URL subURL = new URL(protocol, host, port, file); File newFile; if (cacheList.containsKey(subURL.toExternalForm())) { newFile = cacheList.get(subURL.toExternalForm()); } else { InputStream is = (InputStream) subURL.getContent(); String update = subURL.toExternalForm().replace(":", "_"); update = update.replace("/", "-"); File f = File.createTempFile("pack", update); f.deleteOnExit(); FileOutputStream fostream = new FileOutputStream(f); copyStream(new BufferedInputStream(is), fostream); // Unpack newFile = File.createTempFile("unpack", update); newFile.deleteOnExit(); fostream = new FileOutputStream(newFile); BufferedOutputStream bos = new BufferedOutputStream(fostream, 50 * 1024); JarOutputStream jostream = new JarOutputStream(bos); Unpacker unpacker = Pack200.newUnpacker(); long start = System.currentTimeMillis(); unpacker.unpack(f, jostream); printMessage( "Unpack of " + update + " took " + (System.currentTimeMillis() - start) + "ms"); jostream.close(); fostream.close(); cacheList.put(subURL.toExternalForm(), newFile); } if (internalFile != null) { URL directoryURL = new URL("jar:" + newFile.toURL().toExternalForm() + "!/" + internalFile); printMessage("Using DirectoryURL:" + directoryURL); return directoryURL.openConnection(); } else return newFile.toURL().openConnection(); } catch (Exception ex) { ex.printStackTrace(); } printMessage("Returning null for: " + u.toExternalForm()); return null; }
/** * Convert the document from a PDF to a lucene document. * * @param url A url to a PDF document. * @return The PDF converted to a lucene document. * @throws IOException If there is an error while converting the document. */ public Document convertDocument(URL url) throws IOException { Document document = new Document(); URLConnection connection = url.openConnection(); connection.connect(); // Add the url as a field named "url". Use an UnIndexed field, so // that the url is just stored with the document, but is not searchable. addUnindexedField(document, "url", url.toExternalForm()); // Add the last modified date of the file a field named "modified". Use a // Keyword field, so that it's searchable, but so that no attempt is made // to tokenize the field into words. addKeywordField(document, "modified", timeToString(connection.getLastModified())); String uid = createUID(url, connection.getLastModified()); // Add the uid as a field, so that index can be incrementally maintained. // This field is not stored with document, it is indexed, but it is not // tokenized prior to indexing. addUnstoredKeywordField(document, "uid", uid); InputStream input = null; try { input = connection.getInputStream(); addContent(document, input, url.toExternalForm()); } finally { if (input != null) { input.close(); } } // return the document return document; }
protected ResolvedResource getArtifactRef(Artifact artifact, Date date) { IvyContext.getContext().set(getName() + ".artifact", artifact); try { ResolvedResource ret = findArtifactRef(artifact, date); if (ret == null && artifact.getUrl() != null) { URL url = artifact.getUrl(); Message.verbose("\tusing url for " + artifact + ": " + url); logArtifactAttempt(artifact, url.toExternalForm()); Resource resource; if ("file".equals(url.getProtocol())) { File f; try { f = new File(new URI(url.toExternalForm())); } catch (URISyntaxException e) { // unexpected, try to get the best of it f = new File(url.getPath()); } resource = new FileResource(new FileRepository(), f); } else { resource = new URLResource(url); } ret = new ResolvedResource(resource, artifact.getModuleRevisionId().getRevision()); } return ret; } finally { IvyContext.getContext().set(getName() + ".artifact", null); } }
/** * Initializes the URL that will be used for web service access * * @param deploymentId Deployment ID * @param url URL of the server instance * @return An URL that can be used for the web services */ private URL initializeServicesUrl(URL url, String servicePrefix) { if (url == null) { throw new IllegalArgumentException("The url may not be empty or null."); } try { url.toURI(); } catch (URISyntaxException urise) { throw new IllegalArgumentException( "URL (" + url.toExternalForm() + ") is incorrectly formatted: " + urise.getMessage(), urise); } String urlString = url.toExternalForm(); if (!urlString.endsWith("/")) { urlString += "/"; } urlString += servicePrefix; URL serverPlusServicePrefixUrl; try { serverPlusServicePrefixUrl = new URL(urlString); } catch (MalformedURLException murle) { throw new IllegalArgumentException( "URL (" + url.toExternalForm() + ") is incorrectly formatted: " + murle.getMessage(), murle); } return serverPlusServicePrefixUrl; }
/** Used for redirections or when discovering sitemap URLs * */ private void handleOutlink(Tuple t, URL sURL, String newUrl, Metadata sourceMetadata) { // build an absolute URL try { URL tmpURL = URLUtil.resolveURL(sURL, newUrl); newUrl = tmpURL.toExternalForm(); } catch (MalformedURLException e) { LOG.debug("MalformedURLException on {} or {}: {}", sURL.toExternalForm(), newUrl, e); return; } // apply URL filters if (this.urlFilters != null) { newUrl = this.urlFilters.filter(sURL, sourceMetadata, newUrl); } // filtered if (newUrl == null) { return; } Metadata metadata = metadataTransfer.getMetaForOutlink(newUrl, sURL.toExternalForm(), sourceMetadata); // TODO check that hasn't exceeded max number of redirections _collector.emit( com.digitalpebble.storm.crawler.Constants.StatusStreamName, t, new Values(newUrl, metadata, Status.DISCOVERED)); }
@Override public NodeTypeIterator registerNodeTypes(URL url, boolean allowUpdate) throws IOException, RepositoryException { String content = IoUtil.read(url.openStream()); if (content.startsWith("<?xml")) { // This is Jackrabbit XML format ... return registerNodeTypes( importFromXml(new InputSource(new StringReader(content))), allowUpdate); } // Assume this is CND format ... CndImporter importer = new CndImporter(context(), true); Problems problems = new SimpleProblems(); importer.importFrom(content, problems, url.toExternalForm()); // Check for (and report) any problems ... if (problems.hasProblems()) { // There are errors and/or warnings, so report them ... String summary = messageFrom(problems); if (problems.hasErrors()) { String msg = JcrI18n.errorsParsingNodeTypeDefinitions.text(url.toExternalForm(), summary); throw new RepositoryException(msg); } // Otherwise, there are warnings, so log them ... I18n msg = JcrI18n.warningsParsingNodeTypeDefinitions; Logger.getLogger(getClass()).warn(msg, url.toExternalForm(), summary); } // Register the node types ... return registerNodeTypes(importer.getNodeTypeDefinitions(), allowUpdate); }
/** * 获取类的class文件位置的URL * * @param cls * @return */ private static URL getClassLocationURL(final Class cls) { if (cls == null) throw new IllegalArgumentException("null input: cls"); URL result = null; final String clsAsResource = cls.getName().replace('.', '/').concat(".class"); final ProtectionDomain pd = cls.getProtectionDomain(); if (pd != null) { final CodeSource cs = pd.getCodeSource(); if (cs != null) result = cs.getLocation(); if (result != null) { if ("file".equals(result.getProtocol())) { try { if (result.toExternalForm().endsWith(".jar") || result.toExternalForm().endsWith(".zip")) result = new URL( "jar:".concat(result.toExternalForm()).concat("!/").concat(clsAsResource)); else if (new File(result.getFile()).isDirectory()) result = new URL(result, clsAsResource); } catch (MalformedURLException ignore) { } } } } if (result == null) { final ClassLoader clsLoader = cls.getClassLoader(); result = clsLoader != null ? clsLoader.getResource(clsAsResource) : ClassLoader.getSystemResource(clsAsResource); } return result; }
/** * Returns the location of the Javadoc. * * @param element whose Javadoc location has to be found * @param isBinary <code>true</code> if the Java element is from a binary container * @return the location URL of the Javadoc or <code>null</code> if the location cannot be found * @throws JavaModelException thrown when the Java element cannot be accessed * @since 3.9 */ public static String getBaseURL(IJavaElement element, boolean isBinary) throws JavaModelException { if (isBinary) { // Source attachment usually does not include Javadoc resources // => Always use the Javadoc location as base: URL baseURL = JavaUI.getJavadocLocation(element, false); if (baseURL != null) { if (baseURL.getProtocol().equals(JAR_PROTOCOL)) { // It's a JarURLConnection, which is not known to the browser widget. // Let's start the help web server: URL baseURL2 = PlatformUI.getWorkbench().getHelpSystem().resolve(baseURL.toExternalForm(), true); if (baseURL2 != null) { // can be null if org.eclipse.help.ui is not available baseURL = baseURL2; } } return baseURL.toExternalForm(); } } else { IResource resource = element.getResource(); if (resource != null) { /* * Too bad: Browser widget knows nothing about EFS and custom URL handlers, * so IResource#getLocationURI() does not work in all cases. * We only support the local file system for now. * A solution could be https://bugs.eclipse.org/bugs/show_bug.cgi?id=149022 . */ IPath location = resource.getLocation(); if (location != null) return location.toFile().toURI().toString(); } } return null; }
/** * Check if the resource is an eDoc. * * @param uri - the resource's URI. * @return true if the resource is an (KOBV) eDoc. */ public static boolean isEDoc(String uri) { // test local file system File f = new File(uri); if (f.getParentFile().getName().equals("pdf") && new File(f.getParentFile().getParentFile(), "index.html").exists()) { return true; } else { // test HTTP try { URL url = new URL(uri); int pos = url.toExternalForm().lastIndexOf("/pdf"); if (pos != -1) { String newUrl = url.toExternalForm().substring(0, pos) + "/index.html"; URL indexUrl = new URL(newUrl); @SuppressWarnings("unused") URLConnection conn = indexUrl.openConnection(); return true; } return false; } catch (MalformedURLException e) { return false; } catch (IOException e) { return false; } } }
/** * Tests access to the given web application URL. * * @param webAppURL * @throws Exception */ private void testAccess(@ArquillianResource URL webAppURL) throws Exception { final URL servletURL = new URL(webAppURL.toExternalForm() + SimpleSecuredServlet.SERVLET_PATH.substring(1)); LOGGER.info("Testing successful authentication - " + servletURL); assertEquals( "Expected response body doesn't match the returned one.", SimpleSecuredServlet.RESPONSE_BODY, Utils.makeCallWithBasicAuthn(servletURL, "jduke", "theduke", 200)); LOGGER.info("Testing failed authentication - " + servletURL); Utils.makeCallWithBasicAuthn(servletURL, "anil", "theduke", 401); Utils.makeCallWithBasicAuthn(servletURL, "jduke", "anil", 401); Utils.makeCallWithBasicAuthn(servletURL, "anil", "anil", 401); LOGGER.info("Testing failed authorization - " + servletURL); Utils.makeCallWithBasicAuthn(servletURL, "tester", "password", 403); final URL unprotectedURL = new URL(webAppURL.toExternalForm() + SimpleServlet.SERVLET_PATH.substring(1)); LOGGER.info("Testing access to unprotected resource - " + unprotectedURL); assertEquals( "Expected response body doesn't match the returned one.", SimpleServlet.RESPONSE_BODY, Utils.makeCallWithBasicAuthn(unprotectedURL, null, null, 200)); }
public static StringBuffer _parseItem( Log log, IndexWriter writer, String root, URL url, List urlsDone, String[] extensions, boolean recurse, int deep, long timeout) throws IOException { try { url = translateURL(url); if (urlsDone.contains(url.toExternalForm())) return null; urlsDone.add(url.toExternalForm()); StringBuffer content = new StringBuffer(); Document doc = toDocument(content, writer, root, url, timeout); if (doc == null) return null; if (writer != null) writer.addDocument(doc); // Test /*Resource dir = ResourcesImpl.getFileResourceProvider().getResource("/Users/mic/Temp/leeway3/"); if(!dir.isDirectory())dir.mkdirs(); Resource file=dir.getRealResource(url.toExternalForm().replace("/", "_")); IOUtil.write(file, content.toString(), "UTF-8", false);*/ info(log, url.toExternalForm()); return content; } catch (IOException ioe) { error(log, url.toExternalForm(), ioe); throw ioe; } }
/** * Create an OAR * * @param url The URL for the OperationalString Archive * @throws OARException If the manifest cannot be read * @throws IllegalArgumentException If the url is null */ public OAR(URL url) throws OARException { if (url == null) throw new IllegalArgumentException("url cannot be null"); JarFile jar = null; try { URL oarURL; if (url.getProtocol().equals("jar")) { oarURL = url; } else { StringBuilder sb = new StringBuilder(); sb.append("jar:").append(url.toExternalForm()).append("!/"); oarURL = new URL(sb.toString()); } JarURLConnection conn = (JarURLConnection) oarURL.openConnection(); jar = conn.getJarFile(); Manifest man = jar.getManifest(); getManifestAttributes(man); loadRepositories(jar); jar.close(); this.url = url; } catch (Exception e) { throw new OARException("Problem processing " + url.toExternalForm(), e); } finally { try { if (jar != null) jar.close(); } catch (IOException e) { e.printStackTrace(); } } }
/** * Get an absolute URL from a URL attribute that may be relative (i.e. an <code><a href></code> * or <code><img src></code>). * * <p>E.g.: <code>String absUrl = linkEl.absUrl("href");</code> * * <p>If the attribute value is already absolute (i.e. it starts with a protocol, like <code> * http://</code> or <code>https://</code> etc), and it successfully parses as a URL, the * attribute is returned directly. Otherwise, it is treated as a URL relative to the element's * {@link #baseUri}, and made absolute using that. * * <p>As an alternate, you can use the {@link #attr} method with the <code>abs:</code> prefix, * e.g.: <code>String absUrl = linkEl.attr("abs:href");</code> * * @param attributeKey The attribute key * @return An absolute URL if one could be made, or an empty string (not null) if the attribute * was missing or could not be made successfully into a URL. * @see #attr * @see java.net.URL#URL(java.net.URL, String) */ public String absUrl(String attributeKey) { Validate.notEmpty(attributeKey); String relUrl = attr(attributeKey); if (!hasAttr(attributeKey)) { return ""; // nothing to make absolute with } else { URL base; try { try { base = new URL(baseUri); } catch (MalformedURLException e) { // the base is unsuitable, but the attribute may be abs on its own, so try that URL abs = new URL(relUrl); return abs.toExternalForm(); } // workaround: java resolves '//path/file + ?foo' to '//path/?foo', not '//path/file?foo' as // desired if (relUrl.startsWith("?")) relUrl = base.getPath() + relUrl; URL abs = new URL(base, relUrl); return abs.toExternalForm(); } catch (MalformedURLException e) { return ""; } } }
/** * Allow the application to resolve external entities. * * <p>The strategy we follow is: * * <p>We first check whether the DTD points to a well defined URI, and resolve to our internal * DTDs. * * <p>If the systemId points to a file, then we attempt to read the DTD from the filesystem, in * case they've been modified by the user. Otherwise, we fallback to the built-in DTDs inside * jPOS. * * <p> * * @param publicId The public identifier of the external entity being referenced, or null if * none was supplied. * @param systemId The system identifier of the external entity being referenced. * @return An InputSource object describing the new input source, or null to request that the * parser open a regular URI connection to the system identifier. * @throws org.xml.sax.SAXException Any SAX exception, possibly wrapping another exception. * @throws java.io.IOException A Java-specific IO exception, possibly the result of creating a * new InputStream or Reader for the InputSource. * @see org.xml.sax.InputSource */ public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException { if (systemId == null) return null; ClassLoader cl = Thread.currentThread().getContextClassLoader(); cl = cl == null ? ClassLoader.getSystemClassLoader() : cl; if (systemId.equals("http://jpos.org/dtd/generic-packager-1.0.dtd")) { final URL resource = cl.getResource("org/jpos/iso/packager/genericpackager.dtd"); return new InputSource(resource.toExternalForm()); } else if (systemId.equals("http://jpos.org/dtd/generic-validating-packager-1.0.dtd")) { final URL resource = cl.getResource("org/jpos/iso/packager/generic-validating-packager.dtd"); return new InputSource(resource.toExternalForm()); } URL url = new URL(systemId); if (url.getProtocol().equals("file")) { String file = url.getFile(); if (file.endsWith(".dtd")) { File f = new File(file); InputStream res = null; if (f.exists()) { res = new FileInputStream(f); } if (res == null) { String dtdResource = "org/jpos/iso/packager/" + f.getName(); res = cl.getResourceAsStream(dtdResource); } if (res != null) return new InputSource(res); } } return null; }
private String getPolitenessKey(URL u) { String key = null; if (QUEUE_MODE_IP.equalsIgnoreCase(queueMode)) { try { final InetAddress addr = InetAddress.getByName(u.getHost()); key = addr.getHostAddress(); } catch (final UnknownHostException e) { // unable to resolve it, so don't fall back to host name LOG.warn("Unable to resolve: {}, skipping.", u.getHost()); return null; } } else if (QUEUE_MODE_DOMAIN.equalsIgnoreCase(queueMode)) { key = PaidLevelDomain.getPLD(u.getHost()); if (key == null) { LOG.warn("Unknown domain for url: {}, using hostname as key", u.toExternalForm()); key = u.getHost(); } } else { key = u.getHost(); if (key == null) { LOG.warn("Unknown host for url: {}, using URL string as key", u.toExternalForm()); key = u.toExternalForm(); } } return key.toLowerCase(Locale.ROOT); }
private void addRepository( URL index, Set<URL> visited, List<? super Repository> repos, int hopCount, URLConnector connector, File cacheDir) throws Exception { if (visited.add(index)) { CachingURLResourceHandle handle = new CachingURLResourceHandle( index.toExternalForm(), null, cacheDir, connector, CachingMode.PreferRemote); handle.setReporter(Central.getWorkspace()); File file = handle.request(); PullParser repoParser = new PullParser(); RepositoryImpl repo = repoParser.parseRepository(new FileInputStream(file)); repo.setURI(index.toExternalForm()); repos.add(repo); hopCount--; if (hopCount > 0 && repo.getReferrals() != null) { for (Referral referral : repo.getReferrals()) { URL referralUrl = new URL(index, referral.getUrl()); hopCount = (referral.getDepth() > hopCount) ? hopCount : referral.getDepth(); addRepository(referralUrl, visited, repos, hopCount, connector, cacheDir); } } } }
/** * Loads settings from a url that represents them using the {@link * SettingsLoaderFactory#loaderFromSource(String)}. */ public Builder loadFromUrl(URL url) throws SettingsException { try { return loadFromStream(url.toExternalForm(), url.openStream()); } catch (IOException e) { throw new SettingsException( "Failed to open stream for url [" + url.toExternalForm() + "]", e); } }
/** * Returns whether the given URLs are equal - either may be <code>null</code>. * * @param url1 URL to be compared * @param url2 URL to be compared * @return whether the given URLs are equal */ protected boolean equalURLs(URL url1, URL url2) { if (url1 == null) { return url2 == null; } if (url2 == null) { return false; } return url1.toExternalForm().equals(url2.toExternalForm()); }
@Override public boolean exec(MethodContext methodContext) throws MiniLangException { List<Object> messages = errorListFma.get(methodContext.getEnvMap()); if (messages == null) { messages = new LinkedList<Object>(); errorListFma.put(methodContext.getEnvMap(), messages); } String location = this.locationFse.expandString(methodContext.getEnvMap()); Delegator delegator = getDelegator(methodContext); URL dataUrl = null; try { dataUrl = FlexibleLocation.resolveLocation(location, methodContext.getLoader()); } catch (MalformedURLException e) { messages.add( "Could not find Entity Data document in resource: " + location + "; error was: " + e.toString()); } if (dataUrl == null) { messages.add("Could not find Entity Data document in resource: " + location); } if ("assert".equals(mode)) { try { EntityDataAssert.assertData(dataUrl, delegator, messages); } catch (Exception e) { String xmlError = "Error checking/asserting XML Resource \"" + dataUrl.toExternalForm() + "\"; Error was: " + e.getMessage(); messages.add(xmlError); Debug.logWarning(e, xmlError, module); } } else { try { EntitySaxReader reader = null; if (timeout > 0) { reader = new EntitySaxReader(delegator, timeout); } else { reader = new EntitySaxReader(delegator); } reader.parse(dataUrl); } catch (Exception e) { String xmlError = "Error loading XML Resource \"" + dataUrl.toExternalForm() + "\"; Error was: " + e.getMessage(); messages.add(xmlError); Debug.logWarning(e, xmlError, module); } } return true; }
private String source(URL url) { File baseDirectory = dataDir().getResourceLoader().getBaseDirectory(); if (url.getProtocol().equals("file")) { File file = Files.url(baseDirectory, url.toExternalForm()); if (file != null && !file.isAbsolute()) { return Paths.convert(baseDirectory, file); } } return url.toExternalForm(); }
@Nullable public static String getCssReference(@Nonnull final String baseName) { @Nullable final URL bss = Util.class.getResource(baseName + ".bss"); if (bss != null) { return bss.toExternalForm(); } @Nullable final URL css = Util.class.getResource(baseName + ".css"); if (css != null) { return css.toExternalForm(); } return null; }
/** * Renvoie l'url du r?pertoire parent du fichier ou r?pertoire correspondant ? l'URL donn?e, ou * null si l'on ne peut pas d?terminer le r?pertoire parent. */ protected static URL getURLParent(final URL u) { final int index = u.toExternalForm().lastIndexOf("/"); if (index >= 0) { try { return (new URL(u.toExternalForm().substring(0, index))); } catch (final MalformedURLException ex) { LOG.error("getURLParent(" + u + ") : MalformedURLException", ex); return (null); } } return (null); }
private void updateLafDarcula() { Platform.runLater( () -> { final URL engineStyleUrl = getClass().getResource("/style/javaFXBrowserDarcula.css"); final URL scrollBarStyleUrl = getClass().getResource("/style/javaFXBrowserDarculaScrollBar.css"); myEngine.setUserStyleSheetLocation(engineStyleUrl.toExternalForm()); myPane.getStylesheets().add(scrollBarStyleUrl.toExternalForm()); myPane.setStyle("-fx-background-color: #3c3f41"); myPanel.getScene().getStylesheets().add(engineStyleUrl.toExternalForm()); myEngine.reload(); }); }
private void compareQuery(URL htmlURL, URL compareURL) throws SAXException, IOException { Query query = QueryFactory.read(compareURL.toExternalForm()); Map<String, Query> qs = QueryUtilities.makeQueries(ParserFactory.Format.XHTML, htmlURL.toExternalForm()); assertTrue("We have a query", qs.size() != 0); Query qFromHTML = qs.get(qs.keySet().toArray()[0]); assertEquals( "Query matches (" + htmlURL + ")", Algebra.compile(query), Algebra.compile(qFromHTML)); }
/** * Guess url. * * @param baseURL the base url * @param spec the spec * @return the url * @throws MalformedURLException the malformed url exception */ public static URL guessURL(URL baseURL, String spec) throws MalformedURLException { URL finalURL = null; try { if (baseURL != null) { int colonIdx = spec.indexOf(':'); String newProtocol = colonIdx == -1 ? null : spec.substring(0, colonIdx); if ((newProtocol != null) && !newProtocol.equalsIgnoreCase(baseURL.getProtocol())) { baseURL = null; } } finalURL = createURL(baseURL, spec); } catch (MalformedURLException | UnsupportedEncodingException mfu) { spec = spec.trim(); int idx = spec.indexOf(':'); if (idx == -1) { int slashIdx = spec.indexOf('/'); if (slashIdx == 0) { // A file, absolute finalURL = new URL("file:" + spec); } else { if (slashIdx == -1) { // No slash, no colon, must be host. finalURL = new URL(baseURL, "http://" + spec); } else { String possibleHost = spec.substring(0, slashIdx).toLowerCase(); if (Domains.isLikelyHostName(possibleHost)) { finalURL = new URL(baseURL, "http://" + spec); } else { finalURL = new URL(baseURL, "file:" + spec); } } } } else { if (idx == 1) { // Likely a drive finalURL = new URL(baseURL, "file:" + spec); } else { try { throw mfu; } catch (IOException e) { // TODO Auto-generated catch block logger.severe(e.getMessage()); } } } } if (!"".equals(finalURL.getHost()) && (finalURL.toExternalForm().indexOf(' ') != -1)) { throw new MalformedURLException("There are blanks in the URL: " + finalURL.toExternalForm()); } return finalURL; }
@DataBoundConstructor public RedmineSite(String name, URL url, String apiAccessKey, String projectId) { if (!url.toExternalForm().endsWith("/")) { try { url = new URL(url.toExternalForm() + "/"); } catch (MalformedURLException e) { throw new AssertionError(e); // impossible } } this.name = name; this.url = url; this.apiAccessKey = apiAccessKey; this.projectId = projectId; }
@Override protected void informResponse( TRTrackerAnnouncerHelper helper, TRTrackerAnnouncerResponse response) { URL url = response.getURL(); // can be null for external plugins (e.g. mldht...) if (url != null) { synchronized (this) { String key = url.toExternalForm(); StatusSummary summary = recent_responses.get(key); if (summary != null) { summary.updateFrom(response); } } } last_response_informed = response; // force recalc of best active next time last_best_active_set_time = 0; super.informResponse(helper, response); if (response.getStatus() != TRTrackerAnnouncerResponse.ST_ONLINE) { URL u = response.getURL(); if (u != null) { String s = u.toExternalForm(); synchronized (failed_urls) { if (failed_urls.contains(s)) { return; } failed_urls.add(s); } } checkActivation(true); } }
private static File computeApplicationDir(URL location, File defaultDir) { if (location == null) { System.out.println("Warning: Cannot locate the program directory. Assuming default."); return defaultDir; } if (!"file".equalsIgnoreCase(location.getProtocol())) { System.out.println("Warning: Unrecognized location type. Assuming default."); return new File("."); } String file = location.getFile(); if (!file.endsWith(".jar") && !file.endsWith(".zip")) { try { return (new File(URLDecoder.decode(location.getFile(), "UTF-8"))).getParentFile(); } catch (UnsupportedEncodingException e) { } System.out.println("Warning: Unrecognized location type. Assuming default."); return new File(location.getFile()); } else { try { File path = null; // new File(URLDecoder.decode(location.toExternalForm().substring(6), // "UTF-8")).getParentFile(); if (!CommonLauncher.isLinux() && !CommonLauncher.isOSX()) { path = new File(URLDecoder.decode(location.toExternalForm().substring(6), "UTF-8")) .getParentFile(); } else { path = new File(URLDecoder.decode(location.toExternalForm().substring(5), "UTF-8")) .getParentFile(); } // System.out.println("path: " + path.getAbsolutePath()); // System.out.println("location: " + location.getPath()); // System.out.println("external from location: " + // URLDecoder.decode(location.toExternalForm().substring(6), "UTF-8")); // System.out.println("external from location + 6: " + // URLDecoder.decode(location.toExternalForm(), "UTF-8")); return path; } catch (UnsupportedEncodingException e) { // TODO Auto-generated catch block e.printStackTrace(); } } System.out.println("Warning: Unrecognized location type. Assuming default."); return new File(location.getFile()); }
private void evalUrlAndPop(URL urlIn) throws SoarException { final URL url = normalizeUrl(urlIn); try { fileStack.push(url.toExternalForm()); if (topLevelState != null) { topLevelState.files.add(new FileInfo(url.toExternalForm())); } interp.eval(url); } finally { fileStack.pop(); popd(); } }
private void setDefaultUrl(URL selectedURL) { if (selectedURL != null) { comboUrl.setText(selectedURL.toExternalForm()); url = selectedURL.toExternalForm(); setPageComplete(true); } else if (url != null && url.length() != 0) { comboUrl.setText(url); setPageComplete(true); } else { url = null; comboUrl.setText("http://"); // $NON-NLS-1$ setPageComplete(false); } }