/** Check if an URL is relative to another URL. */ public static boolean relativeURL(URL url1, URL url2) { return ((url1.getProtocol() == null && url2.getProtocol() == null) || url1.getProtocol().equals(url2.getProtocol())) && ((url1.getAuthority() == null && url2.getAuthority() == null) || url1.getAuthority().equals(url2.getAuthority())) && ((url1.getPath() == null && url2.getPath() == null) || url2.getPath().startsWith(url1.getPath())); }
/** * This method fixes incorrect authority attribute that is set by JDK when UNC is used in * classpath. See JDK bug #6585937 and GlassFish issue #3209 for more details. */ private static URL fixUNC(URL url) throws URISyntaxException, MalformedURLException, UnsupportedEncodingException { String protocol = url.getProtocol(); if (!"file".equalsIgnoreCase(protocol)) { return url; } String authority = url.getAuthority(); String file = url.getFile(); if (authority != null) { AbstractSessionLog.getLog() .finer( "fixUNC: before fixing: url = " + url + ", authority = " + authority + ", file = " + file); assert (url.getPort() == -1); // See GlassFish issue https://glassfish.dev.java.net/issues/show_bug.cgi?id=3209 and // JDK issue http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=6585937 // When there is UNC path in classpath, the classloader.getResource // returns a file: URL with an authority component in it. // The URL looks like this: // file://ahost/afile. // Interestingly, authority and file components for the above URL // are either "ahost" and "/afile" or "" and "//ahost/afile" depending on // how the URL is obtained. If classpath is set as a jar with UNC, // the former is true, if the classpath is set as a directory with UNC, // the latter is true. String prefix = ""; if (authority.length() > 0) { prefix = "////"; } else if (file.startsWith("//")) { prefix = "//"; } file = prefix.concat(authority).concat(file); url = new URL(protocol, null, file); AbstractSessionLog.getLog() .finer( "fixUNC: after fixing: url = " + url + ", authority = " + url.getAuthority() + ", file = " + url.getFile()); } return url; }
public String evaluate(String urlStr, String partToExtract) { if (urlStr == null || partToExtract == null) { return null; } if (lastUrlStr == null || !urlStr.equals(lastUrlStr)) { try { url = new URL(urlStr); } catch (Exception e) { return null; } } lastUrlStr = urlStr; if (partToExtract.equals("HOST")) return url.getHost(); if (partToExtract.equals("PATH")) return url.getPath(); if (partToExtract.equals("QUERY")) return url.getQuery(); if (partToExtract.equals("REF")) return url.getRef(); if (partToExtract.equals("PROTOCOL")) return url.getProtocol(); if (partToExtract.equals("FILE")) return url.getFile(); if (partToExtract.equals("AUTHORITY")) return url.getAuthority(); if (partToExtract.equals("USERINFO")) return url.getUserInfo(); return null; }
public static URL getURL(double latitude, double longitude, String output) throws MalformedURLException, IOException { StringBuilder stringBuilder = new StringBuilder(URL_PREFIX); stringBuilder.append("?"); stringBuilder.append("output=" + output + "&"); stringBuilder.append("location=" + latitude + "," + longitude + "&"); stringBuilder.append("key=" + PRIVATE_KEY); URL url = new URL(stringBuilder.toString()); System.out.println(String.format("getProtocol %s", url.getProtocol())); System.out.println(String.format("getHost %s", url.getHost())); System.out.println(String.format("getPath %s", url.getPath())); System.out.println(String.format("getPort %s", url.getPort())); System.out.println(String.format("getDefaultPort %s", url.getDefaultPort())); System.out.println(String.format("getQuery %s", url.getQuery())); System.out.println(String.format("getAuthority %s", url.getAuthority())); System.out.println(String.format("getRef %s", url.getRef())); System.out.println(String.format("getUserInfo %s", url.getUserInfo())); System.out.println(String.format("getFile %s", url.getFile())); System.out.println(String.format("getContent %s", url.getContent())); System.out.println(String.format("toExternalForm %s", url.toExternalForm())); System.out.println("---------------"); return url; }
/** * The URL-safe version of a string is obtained by an URL encoding to a string value. * * @throws R2RMLDataError * @throws MalformedURLException */ public static String getURLSafeVersion(String value) throws R2RMLDataError { if (value == null) return null; URL url = null; try { url = new URL(value); } catch (MalformedURLException mue) { // This template should be not a url : no encoding return value; } // No exception raised, this template is a valid url : perform // percent-encoding try { java.net.URI uri = new java.net.URI( url.getProtocol(), url.getAuthority(), url.getPath(), url.getQuery(), url.getRef()); String result = uri.toURL().toString(); // Percent encoding : complete with no supported char in this // treatment result = result.replaceAll("\\,", "%2C"); return result; } catch (URISyntaxException e) { throw new R2RMLDataError( "[R2RMLToolkit:getIRISafeVersion] This value " + value + " can not be percent-encoded because " + e.getMessage()); } catch (MalformedURLException e) { throw new R2RMLDataError( "[R2RMLToolkit:getIRISafeVersion] This value " + value + " can not be percent-encoded because " + e.getMessage()); } }
public static void switch_chan(String httpurl, String hotlink, String userid, Handler handler) { try { String param = "http://127.0.0.1:9898/cmd.xml?cmd=switch_chan&"; URL url = new URL(httpurl.replace("p2p", "http")); String server = url.getAuthority(); String videoId = url.getPath(); videoId = videoId.subSequence(1, videoId.length() - 3).toString(); param += "id=" + videoId; param += "&server=" + server; param += "&link=" + hotlink; param += "&userid=" + userid; String playurl = "http://127.0.0.1:9898/" + videoId + ".ts"; // String playurl="http://111.11.28.16/mrtpweb/aaaa.mp4"; if (tvthread != null) { tvthread.stopreq(); } LogUtils.write(TAG, param); LogUtils.write(TAG, playurl); tvthread = new ForceTvThread(param, playurl, handler); tvthread.start(); } catch (Exception e) { // TODO Auto-generated catch block e.printStackTrace(); } }
private static void setValues( URL url, HttpResponse<InputStream> jsonResponse, AbstractMap<String, String> localHeaders, Long responseTime) { generalInfo = new HashMap<>(); int responseCode = jsonResponse.getStatus(); generalInfo.put("Protocol", url.getProtocol()); generalInfo.put("Authority", url.getAuthority()); generalInfo.put("Host", url.getHost()); generalInfo.put("Default Port", Integer.toString(url.getDefaultPort())); generalInfo.put("Port ", Integer.toString(url.getPort())); generalInfo.put("Path", url.getPath()); generalInfo.put("Query", url.getQuery()); generalInfo.put("Filename", url.getFile()); generalInfo.put("Ref", url.getRef()); responseValues.resetProperties(); responseValues.setRequestHeaders(localHeaders); responseValues.setResponseHeaders(jsonResponse.getHeaders()); responseValues.setGeneralInfo(generalInfo); responseValues.setResponseTime(responseTime); responseValues.setResponseCode( Integer.toString(responseCode) + " " + jsonResponse.getStatusText()); }
public URLConnection openConnection(URL url) throws IOException { String projectID = url.getAuthority(); AWorkspaceProject project = WorkspaceController.getCachedProjectByID(projectID); if (project == null) { throw new IOException("project with id=" + projectID + " is missing"); } URL absolutePath = resolve(project, url); return absolutePath.openConnection(); }
/** * @param args * @throws MalformedURLException */ public static void main(String[] args) throws MalformedURLException { // TODO Auto-generated method stub URL url = new URL("http://www.baidu.com"); URL tuto = new URL(url, "tutorial.intro.html#DOWNLOADING"); System.out.println("protocal=" + tuto.getProtocol()); System.out.println("host=" + tuto.getHost()); System.out.println("port=" + tuto.getPort()); System.out.println("Authority=" + tuto.getAuthority()); System.out.println("Path=" + tuto.getPath()); System.out.println("UserInfo=" + tuto.getUserInfo()); System.out.println("DefaultPort=" + tuto.getDefaultPort()); }
public static void main(String[] args) throws IOException { URL url = new URL("http://www.javajeff.com/articles/articles/html"); System.out.println("Authority = " + url.getAuthority()); System.out.println("Default port = " + url.getDefaultPort()); System.out.println("File = " + url.getFile()); System.out.println("Host = " + url.getHost()); System.out.println("Path = " + url.getPath()); System.out.println("Port = " + url.getPort()); System.out.println("Protocol = " + url.getProtocol()); System.out.println("Query = " + url.getQuery()); System.out.println("Ref = " + url.getRef()); System.out.println("User Info = " + url.getUserInfo()); }
@Override public Object invoke(Object proxy, Method method, Object[] args) throws Throwable { Map<String, Object> httpHeaders = new Hashtable<String, Object>(); List<RpcHeader> headers = new ArrayList<RpcHeader>(); Pair<Endpoint, Long> r = preprocess(httpHeaders, headers); Endpoint endpoint = r.getFirst(); long iid = r.getSecond(); URL url = endpoint.getAddress().toURL(); String key = url.getProtocol() + "://" + url.getAuthority() + url.getPath() + "##" + method.getName() + "(" + JSON.encode(args) + ")"; long s = System.currentTimeMillis(); Object ret = cache.getIfPresent(key); if (ret != null) { postprocess( iid, System.currentTimeMillis() - s, new MimeHeaders(), new ArrayList<RpcHeader>(), null); return ret; } else { Object client = clientFactory.create(interfaceClass, endpoint.getAddress().toURL()); RequestAttributes reqAttrs = (RequestAttributes) client; reqAttrs.setUserId(endpoint.getUserName()); reqAttrs.setPassword(endpoint.getPassword()); reqAttrs.addRequestMimeHeaders(httpHeaders); for (RpcHeader h : headers) { reqAttrs.addRequestRpcHeader(h.getNamespace(), h.getName(), h.getValue()); } try { Object result = method.invoke(client, args); cache.put(key, result); return result; } finally { ResponseAttributes resAttrs = (ResponseAttributes) client; postprocess( iid, System.currentTimeMillis() - s, MimeHeadersUtil.fromStringObjectMap(resAttrs.getResponseMimeHeaders()), resAttrs.getResponseRpcHeaders(), resAttrs.getResponseRpcFault()); } } }
private void _log(@Nonnull final URL aURL) throws URISyntaxException { s_aLogger.info("Next URL"); s_aLogger.info(" protocol = " + aURL.getProtocol()); s_aLogger.info(" authority = " + aURL.getAuthority()); s_aLogger.info(" host = " + aURL.getHost()); s_aLogger.info(" port = " + aURL.getPort()); s_aLogger.info(" defaultPort = " + aURL.getDefaultPort()); s_aLogger.info(" path = " + aURL.getPath()); s_aLogger.info(" query = " + aURL.getQuery()); s_aLogger.info(" file = " + aURL.getFile()); s_aLogger.info(" ref = " + aURL.getRef()); s_aLogger.info(" externalForm = " + aURL.toExternalForm()); s_aLogger.info(" URI = " + aURL.toURI().toString()); }
public static void main(String args[]) { URL url = null; try { url = new URL("hdfs://www.daum.net:80"); log.info("Protocol : " + url.getProtocol()); log.info("Host : " + url.getHost()); log.info("Port : " + url.getPort()); log.info("File : " + url.getPath()); log.info("Query : " + url.getQuery()); log.info("Authrioty: " + url.getAuthority()); } catch (MalformedURLException e) { // TODO Auto-generated catch block e.printStackTrace(); } }
@Override public void doComplete(final CompletionInfo completions, final String partial, final int flags) { try { // If 'partial' is a well-formed "file:" URL with no host, port, // user or query, do completion on the path component. URL url = new URL(partial); if (url.getProtocol().equals("file") && (url.getAuthority() == null || url.getAuthority().length() == 0) && (url.getQuery() == null || url.getQuery().length() == 0)) { // Use a FileArgument to do the work of completing the pathname, // capturing the results using our own CompletionInfo object. CompletionInfo myCompletion = new CommandCompletions(); new FileArgument(null, getFlags()).complete(myCompletion, url.getPath(), flags); // Then turn the completions back into "file:" URLs for (String c : myCompletion.getCompletions()) { // (Kludge - the 'true' argument prevents an extra space // character from being appended to the completions.) completions.addCompletion("file:" + c, true); } } } catch (MalformedURLException ex) { // No completion possible } }
public static void main(String[] args) throws IOException { URL url = new URL("http://manuli-agri.com.ua"); URLConnection connection = url.openConnection(); BufferedReader inputStream = new BufferedReader(new InputStreamReader(connection.getInputStream())); BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(new File(url.getAuthority() + ".txt"))); String line; while((line = inputStream.readLine()) != null){ bufferedWriter.write(line); } bufferedWriter.close(); inputStream.close(); }
@Test public void test_javaNetUrl() throws Exception { java.net.URL url = new java.net.URL( "http://*****:*****@10.20.130.230:20880/context/path?version=1.0.0&application=morgan#anchor1"); assertEquals("http", url.getProtocol()); assertEquals("admin:hello1234", url.getUserInfo()); assertEquals("10.20.130.230", url.getHost()); assertEquals(20880, url.getPort()); assertEquals("/context/path", url.getPath()); assertEquals("version=1.0.0&application=morgan", url.getQuery()); assertEquals("anchor1", url.getRef()); assertEquals("admin:[email protected]:20880", url.getAuthority()); assertEquals("/context/path?version=1.0.0&application=morgan", url.getFile()); }
private String getPageUrlFromIconUrl(String iconUrl) { // Addon icon URLs come with a query argument that is usually // used for expiration purposes. We want the "page URL" here to be // stable enough to avoid unnecessary duplicate records of the // same addon. String pageUrl = iconUrl; try { URL urlForIcon = new URL(iconUrl); URL urlForPage = new URL(urlForIcon.getProtocol(), urlForIcon.getAuthority(), urlForIcon.getPath()); pageUrl = urlForPage.toString(); } catch (MalformedURLException e) { // Defaults to pageUrl = iconUrl in case of error } return pageUrl; }
/** * Takes a URL and converts it to a File. The attempts to deal with Windows UNC format specific * problems, specifically files located on network shares and different drives. * * <p>If the URL.getAuthority() returns null or is empty, then only the url's path property is * used to construct the file. Otherwise, the authority is prefixed before the path. * * <p>It is assumed that url.getProtocol returns "file". * * <p>Authority is the drive or network share the file is located on. Such as "C:", "E:", * "\\fooServer" * * @param url a URL object that uses protocol "file" * @return a File that corresponds to the URL's location */ public static File urlToFile(URL url) { if (!"file".equals(url.getProtocol())) { return null; // not a File URL } String string = url.toExternalForm(); if (string.contains("+")) { // this represents an invalid URL created using either // file.toURL(); or // file.toURI().toURL() on a specific version of Java 5 on Mac string = string.replace("+", "%2B"); } try { string = URLDecoder.decode(string, "UTF-8"); } catch (UnsupportedEncodingException e) { throw new RuntimeException("Could not decode the URL to UTF-8 format", e); } String path3; String simplePrefix = "file:/"; String standardPrefix = "file://"; String os = System.getProperty("os.name"); if (os.toUpperCase().contains("WINDOWS") && string.startsWith(standardPrefix)) { // win32: host/share reference path3 = string.substring(standardPrefix.length() - 2); } else if (string.startsWith(standardPrefix)) { path3 = string.substring(standardPrefix.length()); } else if (string.startsWith(simplePrefix)) { path3 = string.substring(simplePrefix.length() - 1); } else { String auth = url.getAuthority(); String path2 = url.getPath().replace("%20", " "); if (auth != null && !auth.equals("")) { path3 = "//" + auth + path2; } else { path3 = path2; } } return new File(path3); }
private String getRootUrl() throws NotFoundException, ReportableError { URL manageUrl = null; try { manageUrl = new URL(this.appSettings.getString("webUrl", "")); } catch (MalformedURLException e) { throw new ReportableError( r.getString(R.string.error_bad_url, (manageUrl == null) ? "" : manageUrl.toString()), e); } String urlPath = manageUrl.getPath(); String[] pathElements = urlPath.split("/"); String directoryActual = "/"; if (pathElements.length > 1) { for (int idx = 0; idx < pathElements.length - 1; idx++) { if (pathElements[idx].length() > 0) { directoryActual += pathElements[idx] + "/"; } } } return manageUrl.getProtocol() + "://" + manageUrl.getAuthority() + directoryActual; }
private String createPublicUrl(String baseUrl, String path) { if (!ObjectUtils.isBlank(baseUrl)) { path = StringUtils.ensureEnd(baseUrl, "/") + path; try { URL url = new URL(path); path = new URI( url.getProtocol(), url.getAuthority(), url.getPath(), url.getQuery(), url.getRef()) .toASCIIString(); } catch (MalformedURLException error) { // Return the path as is if the given path is malformed. } catch (URISyntaxException error) { // Return the path as is if the resolved path is malformed. } } return path; }
/** * Constructs a store from a given URL. The URL should either specify the <code>jar:</code> * protocol, in which case the sub-URL should point to a JAR or ZIP file; or the URL should itself * specify a JAR or ZIP file. Query and reference part of the URL are ignored. The store is * immutable. * * @param url source location of the underlying persistent storage; should refer to a ZIP or JAR * file. * @throws IllegalArgumentException if <code>location</code> does not specify the correct protocol * @throws IOException if the URL has the JAR protocol, but cannot be opened */ public DefaultArchiveSystemStore(URL url) throws IllegalArgumentException, IOException { // first strip query and anchor part try { url = new URL(url.getProtocol(), url.getAuthority(), url.getPath()); } catch (MalformedURLException exc) { assert false : String.format("Stripping URL '%s' throws exception: %s", url, exc); } this.location = url.toString(); // artificially append the jar protocol, if it is not yet there if (!url.getProtocol().equals(JAR_PROTOCOL)) { if (!JAR.hasExtension(url.getPath()) && !ZIP.hasExtension(url.getPath())) { throw new IllegalArgumentException(String.format("URL '%s' is not a JAR or ZIP file", url)); } url = new URL(JAR_PROTOCOL, null, url.toString() + "!/"); } this.entryName = extractEntryName(url); // take the last part of the entry name as grammar name File fileFromEntry = new File(this.entryName); this.grammarName = GRAMMAR.stripExtension(fileFromEntry.getName()); this.url = url; this.file = null; }
// for get url reqs, serialise the data map into the url private static void serialiseRequestUrl(Connection.Request req) throws IOException { URL in = req.url(); StringBuilder url = new StringBuilder(); boolean first = true; // reconstitute the query, ready for appends url.append(in.getProtocol()) .append("://") .append(in.getAuthority()) // includes host, port .append(in.getPath()) .append("?"); if (in.getQuery() != null) { url.append(in.getQuery()); first = false; } for (Connection.KeyVal keyVal : req.data()) { if (!first) url.append('&'); else first = false; url.append(URLEncoder.encode(keyVal.key(), DataUtil.defaultCharset)) .append('=') .append(URLEncoder.encode(keyVal.value(), DataUtil.defaultCharset)); } req.url(new URL(url.toString())); req.data().clear(); // moved into url as get params }
@Override public String toString() { return "<URI:" + restUrl.getAuthority() + "," + NSOtpNode + ">"; }
/** * Creates and returns a new URL identical to the specified URL, except using the specified query * string. * * @param u the URL on which to base the returned URL * @param newQuery the new query string to use in the returned URL * @return a new URL identical to the specified URL, except using the specified query string * @throws MalformedURLException if there is a problem creating the new URL */ public static URL getUrlWithNewQuery(final URL u, final String newQuery) throws MalformedURLException { return createNewUrl(u.getProtocol(), u.getAuthority(), u.getPath(), u.getRef(), newQuery); }
/** * Creates a new URL to the specified resource {@code spec}. This URL is relative to the given * {@code context}. The {@code handler} will be used to parse the URL string representation. If * this argument is {@code null} the default {@code URLStreamHandler} will be used. If the * protocol of the parsed URL does not match with the protocol of the context URL, then the newly * created URL is absolute and bases only on the given URL represented by {@code spec}. Otherwise * the protocol is defined by the context URL. * * @param context the URL which is used as the context. * @param spec the URL string representation which has to be parsed. * @param handler the specific stream handler to be used by this URL. * @throws IOException if the given string {@code spec} could not be parsed as a URL or an invalid * protocol has been found. */ public URL(URL context, String spec) throws MalformedURLException { if (spec == null) { throw new MalformedURLException(); } spec = spec.trim(); this.spec = spec; // The spec includes a protocol if it includes a colon character // before the first occurrence of a slash character. Note that, // "protocol" is the field which holds this URLs protocol. int index; try { index = spec.indexOf(':'); } catch (NullPointerException e) { throw new MalformedURLException(e.toString()); } int startIPv6Addr = spec.indexOf('['); if (index >= 0) { if ((startIPv6Addr == -1) || (index < startIPv6Addr)) { protocol = spec.substring(0, index); // According to RFC 2396 scheme part should match // the following expression: // alpha *( alpha | digit | "+" | "-" | "." ) char c = protocol.charAt(0); boolean valid = ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z'); for (int i = 1; valid && (i < protocol.length()); i++) { c = protocol.charAt(i); valid = ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || (c == '+') || (c == '-') || (c == '.'); } if (!valid) { protocol = null; index = -1; } else { // Ignore case in protocol names. // Scheme is defined by ASCII characters. protocol = protocol.toLowerCase(); } } } if (protocol != null) { // If the context was specified, and it had the same protocol // as the spec, then fill in the receiver's slots from the values // in the context but still allow them to be over-ridden later // by the values in the spec. if (context != null && protocol.equals(context.getProtocol())) { String cPath = context.getPath(); if (cPath != null && cPath.startsWith("/")) { set( protocol, context.getHost(), context.getPort(), context.getAuthority(), context.getUserInfo(), cPath, context.getQuery(), null); } } } else { // If the spec did not include a protocol, then the context // *must* be specified. Fill in the receiver's slots from the // values in the context, but still allow them to be over-ridden // by the values in the ("relative") spec. if (context == null) { throw new MalformedURLException("Protocol not found: " + spec); } set( context.getProtocol(), context.getHost(), context.getPort(), context.getAuthority(), context.getUserInfo(), context.getPath(), context.getQuery(), null); } if (port < -1) { throw new MalformedURLException("Port out of range: " + port); } }
private String pathFrom(String url) throws MalformedURLException { URL defaultUrl = new URL(url); return url.substring( url.indexOf(defaultUrl.getAuthority()) + defaultUrl.getAuthority().length()); }
/** * Generates the service endpoint element from the swagger object. * * @param swaggerObject swagger document object. * @param swaggerVersion swagger version. */ private void createEndpointElement(JsonObject swaggerObject, String swaggerVersion) throws RegistryException { /* Extracting endpoint url from the swagger document. */ if (SwaggerConstants.SWAGGER_VERSION_12.equals(swaggerVersion)) { JsonElement endpointUrlElement = swaggerObject.get(SwaggerConstants.BASE_PATH); if (endpointUrlElement == null) { log.warn( "Endpoint url is not specified in the swagger document. Endpoint creation might fail. "); return; } else { endpointUrl = endpointUrlElement.getAsString(); } } else if (SwaggerConstants.SWAGGER_VERSION_2.equals(swaggerVersion)) { JsonElement transportsElement = swaggerObject.get(SwaggerConstants.SCHEMES); JsonArray transports = (transportsElement != null) ? transportsElement.getAsJsonArray() : null; String transport = (transports != null) ? transports.get(0).getAsString() + "://" : DEFAULT_TRANSPORT; JsonElement hostElement = swaggerObject.get(SwaggerConstants.HOST); String host = (hostElement != null) ? hostElement.getAsString() : null; if (host == null) { log.warn( "Endpoint(host) url is not specified in the swagger document. " + "The host serving the documentation is to be used(including the port) as endpoint host"); if (requestContext.getSourceURL() != null) { URL sourceURL = null; try { sourceURL = new URL(requestContext.getSourceURL()); } catch (MalformedURLException e) { throw new RegistryException("Error in parsing the source URL. ", e); } host = sourceURL.getAuthority(); } } if (host == null) { log.warn( "Can't derive the endpoint(host) url when uploading swagger from file. " + "Endpoint creation might fail. "); return; } JsonElement basePathElement = swaggerObject.get(SwaggerConstants.BASE_PATH); String basePath = (basePathElement != null) ? basePathElement.getAsString() : DEFAULT_BASE_PATH; endpointUrl = transport + host + basePath; } /* Creating endpoint artifact */ OMFactory factory = OMAbstractFactory.getOMFactory(); endpointLocation = EndpointUtils.deriveEndpointFromUrl(endpointUrl); String endpointName = EndpointUtils.deriveEndpointNameWithNamespaceFromUrl(endpointUrl); String endpointContent = EndpointUtils.getEndpointContentWithOverview( endpointUrl, endpointLocation, endpointName, documentVersion); try { endpointElement = AXIOMUtil.stringToOM(factory, endpointContent); } catch (XMLStreamException e) { throw new RegistryException("Error in creating the endpoint element. ", e); } }
/** * Determine the URL path to the persistence unit * * @param pxmlURL - Encoded URL containing the pu * @return * @throws IOException */ public static URL computePURootURL(URL pxmlURL, String descriptorLocation) throws IOException, URISyntaxException { StringTokenizer tokenizer = new StringTokenizer(descriptorLocation, "/\\"); int descriptorDepth = tokenizer.countTokens() - 1; URL result; String protocol = pxmlURL.getProtocol(); if ("file".equals(protocol)) { // NOI18N StringBuffer path = new StringBuffer(); boolean firstElement = true; for (int i = 0; i < descriptorDepth; i++) { if (!firstElement) { path.append("/"); // 315097 URL use standard separators } path.append(".."); firstElement = false; } // e.g. file:/tmp/META-INF/persistence.xml // 210280: any file url will be assumed to always reference a file (not a directory) result = new URL(pxmlURL, path.toString()); // NOI18N } else if ("jar".equals(protocol)) { // NOI18N // e.g. jar:file:/tmp/a_ear/b.jar!/META-INF/persistence.xml JarURLConnection conn = JarURLConnection.class.cast(pxmlURL.openConnection()); result = conn.getJarFileURL(); } else if ("zip".equals(protocol)) { // NOI18N // e.g. zip:/tmp/a_ear/b.jar!/META-INF/persistence.xml // stolen from java.net.JarURLConnection.parseSpecs method String spec = pxmlURL.getFile(); int separator = spec.lastIndexOf("!/"); if (separator == -1) { separator = spec.length() - 1; } result = new File(spec.substring(0, separator++)).toURL(); } else if ("wsjar".equals(protocol)) { // NOI18N // e.g. wsjar:file:/tmp/a_ear/b.jar!/META-INF/persistence.xml // but WS gives use jar:file:..., so we need to match it. String spec = pxmlURL.getFile(); int separator = spec.lastIndexOf("!/"); if (separator == -1) { separator = spec.length(); } else { // If this doesn't reference a war file with a properly located persistence.xml, // then chop off everything after the "!/" marker and assume it is a normal jar. // Else, if the wsjar URL references a file with a ".war" extension, and its entry // starts with WEB-INF/classes/, then the calculated persistence unit root should // be wsjar:path/to/a.war!/WEB-INF/classes/ as per JPA 2.1 Spec section 8.2 "Persistence // Unit Packaging". separator += 2; // Filter out invalid scenarios such as // wsjar:file:/a/path/to/my.war!/foo/WEB-INF/classes/META-INF/persistence.xml if (spec.regionMatches(true, separator - 6, ".war", 0, 4) && spec.regionMatches(true, separator, WEBINF_CLASSES_STR, 0, WEBINF_CLASSES_LEN)) { separator += WEBINF_CLASSES_LEN; } } result = new URL("jar", "", spec.substring(0, separator)); } else if ("bundleentry".equals(protocol)) { // mkeith - add bundle protocol cases result = new URL("bundleentry://" + pxmlURL.getAuthority()); } else if ("bundleresource".equals(protocol)) { result = new URL("bundleresource://" + pxmlURL.getAuthority()); } else { StringBuffer path = new StringBuffer(); for (int i = 0; i < descriptorDepth; i++) { path.append("../"); // 315097 URL use standard separators } // some other protocol result = new URL(pxmlURL, path.toString()); // NOI18N } result = fixUNC(result); return result; }
/** * List directory contents for a resource folder. Not recursive. This is basically a brute-force * implementation. Works for regular files and also JARs. * * @author Greg Briggs * @param clazz Any java class that lives in the same place as the resources you want. * @param path Should end with "/", but not start with one. * @return Just the name of each member item, not the full paths. * @throws URISyntaxException * @throws IOException */ public static String[] getResourceListing(Class clazz, String path) throws URISyntaxException, IOException { ClassLoader classLoader = clazz.getClassLoader(); URL dirURL = clazz.getClassLoader().getResource(path); if (dirURL != null && dirURL.getProtocol().equals("file")) { /* A file path: easy enough */ System.out.println("dirURL.getAuthority(); = |" + dirURL.getAuthority() + "|."); System.out.println("dirURL.getPath(); = |" + dirURL.getPath() + "|."); String[] resourceListing = new File(dirURL.toURI()).list(); printList(resourceListing, path); return resourceListing; } if (dirURL == null) { /* * In case of a jar file, we can't actually find a directory. * Have to assume the same jar as clazz. */ String me = clazz.getName().replace(".", "/") + ".class"; dirURL = clazz.getClassLoader().getResource(me); } log.info( "after dirURL == null and reset dirURL: dirURL.getAuthority(); = |" + dirURL.getAuthority() + "|."); log.info( "after dirURL == null and reset dirURL: dirURL.getPath(); = |" + dirURL.getPath() + "|."); if (dirURL.getProtocol().equals("jar")) { /* A JAR path */ String jarPath = dirURL .getPath() .substring(5, dirURL.getPath().indexOf("!")); // strip out only the JAR file JarFile jar = new JarFile(URLDecoder.decode(jarPath, "UTF-8")); Enumeration<JarEntry> entries = jar.entries(); // gives ALL entries in jar Set<String> result = new HashSet<String>(); // avoid duplicates in case it is a subdirectory while (entries.hasMoreElements()) { String name = entries.nextElement().getName(); if (name.startsWith(path)) { // filter according to the path String entry = name.substring(path.length()); int checkSubdir = entry.indexOf("/"); if (checkSubdir >= 0) { // if it is a subdirectory, we just return the directory name entry = entry.substring(0, checkSubdir); } result.add(entry); } } String[] resourceListing = result.toArray(new String[result.size()]); printList(resourceListing, path); return resourceListing; } throw new UnsupportedOperationException("Cannot list files for URL " + dirURL); }