コード例 #1
0
 public static void setETag(URIConverter uriConverter, URI file, String eTag) {
   try {
     if (eTag != null) {
       BaseUtil.writeFile(
           uriConverter, null, file.appendFileExtension("etag"), eTag.getBytes("UTF-8"));
     } else {
       BaseUtil.deleteFile(uriConverter, null, file);
     }
   } catch (IORuntimeException ex) {
     // If we can't write the ETag, perhaps some other process is writing it, but it's expected to
     // write the same ETag value.
   } catch (UnsupportedEncodingException ex) {
     // All systems support UTF-8.
   }
 }
コード例 #2
0
  public static String getETag(URIConverter uriConverter, URI file) {
    if (uriConverter.exists(file, null)) {
      URI eTagFile = file.appendFileExtension("etag");
      if (uriConverter.exists(eTagFile, null)) {
        try {
          return new String(BaseUtil.readFile(uriConverter, null, eTagFile), "UTF-8");
        } catch (IORuntimeException ex) {
          // If we can't read the ETag, we'll just return null.
        } catch (UnsupportedEncodingException ex) {
          // All systems support UTF-8.
        }
      }
    }

    return null;
  }
コード例 #3
0
  @Override
  public InputStream createInputStream(URI uri, Map<?, ?> options) throws IOException {
    if (TEST_IO_EXCEPTION) {
      File folder = new File(CACHE_FOLDER.toFileString());
      if (folder.isDirectory()) {
        System.out.println("Deleting cache folder: " + folder);
        IOUtil.deleteBestEffort(folder);
      }

      throw new IOException("Simulated network problem");
    }

    CacheHandling cacheHandling = getCacheHandling(options);
    URIConverter uriConverter = getURIConverter(options);
    URI cacheURI = getCacheFile(uri);
    String eTag =
        cacheHandling == CacheHandling.CACHE_IGNORE ? null : getETag(uriConverter, cacheURI);
    String expectedETag = cacheHandling == CacheHandling.CACHE_IGNORE ? null : getExpectedETag(uri);
    if (expectedETag != null
        || cacheHandling == CacheHandling.CACHE_ONLY
        || cacheHandling == CacheHandling.CACHE_WITHOUT_ETAG_CHECKING) {
      if (cacheHandling == CacheHandling.CACHE_ONLY
              || cacheHandling == CacheHandling.CACHE_WITHOUT_ETAG_CHECKING
          ? eTag != null
          : expectedETag.equals(eTag)) {
        try {
          setExpectedETag(uri, expectedETag);
          return uriConverter.createInputStream(cacheURI, options);
        } catch (IOException ex) {
          // Perhaps another JVM is busy writing this file.
          // Proceed as if it doesn't exit.
        }
      }
    }

    String username;
    String password;

    String uriString = uri.toString();
    Proxy proxy = ProxySetupHelper.getProxy(uriString);
    if (proxy != null) {
      username = proxy.getUsername();
      password = proxy.getPassword();
    } else {
      username = null;
      password = null;
    }

    IContainer container = createContainer();

    AuthorizationHandler authorizatonHandler = getAuthorizatonHandler(options);
    Authorization authorization = getAuthorizaton(options);
    int triedReauthorization = 0;
    for (int i = 0; ; ++i) {
      IRetrieveFileTransferContainerAdapter fileTransfer =
          container.getAdapter(IRetrieveFileTransferContainerAdapter.class);

      if (proxy != null) {
        fileTransfer.setProxy(proxy);

        if (username != null) {
          fileTransfer.setConnectContextForAuthentication(
              ConnectContextFactory.createUsernamePasswordConnectContext(username, password));
        } else if (password != null) {
          fileTransfer.setConnectContextForAuthentication(
              ConnectContextFactory.createPasswordConnectContext(password));
        }
      }

      FileTransferListener transferListener = new FileTransferListener(eTag);

      try {
        FileTransferID fileTransferID =
            new FileTransferID(new FileTransferNamespace(), IOUtil.newURI(uriString));
        Map<Object, Object> requestOptions = new HashMap<Object, Object>();
        requestOptions.put(IRetrieveFileTransferOptions.CONNECT_TIMEOUT, 10000);
        requestOptions.put(IRetrieveFileTransferOptions.READ_TIMEOUT, 10000);
        if (authorization != null && authorization.isAuthorized()) {
          requestOptions.put(
              IRetrieveFileTransferOptions.REQUEST_HEADERS,
              Collections.singletonMap("Authorization", authorization.getAuthorization()));
        }

        fileTransfer.sendRetrieveRequest(fileTransferID, transferListener, requestOptions);
      } catch (IncomingFileTransferException ex) {
        throw new IOExceptionWithCause(ex);
      }
      try {
        transferListener.receiveLatch.await();
      } catch (InterruptedException ex) {
        throw new IOExceptionWithCause(ex);
      }

      if (transferListener.exception != null) {
        if (!(transferListener.exception instanceof UserCancelledException)) {
          if (transferListener.exception.getCause() instanceof SocketTimeoutException && i <= 2) {
            continue;
          }

          if (authorizatonHandler != null
              && transferListener.exception instanceof IncomingFileTransferException) {
            // We assume contents can be accessed via the github API
            // https://developer.github.com/v3/repos/contents/#get-contents
            // That API, for security reasons, does not return HTTP_UNAUTHORIZED, so we need this
            // special case for that host.
            IncomingFileTransferException incomingFileTransferException =
                (IncomingFileTransferException) transferListener.exception;
            int errorCode = incomingFileTransferException.getErrorCode();
            if (errorCode == HttpURLConnection.HTTP_UNAUTHORIZED
                || API_GITHUB_HOST.equals(getHost(uri))
                    && errorCode == HttpURLConnection.HTTP_NOT_FOUND) {
              if (authorization == null) {
                authorization = authorizatonHandler.authorize(uri);
                if (authorization.isAuthorized()) {
                  --i;
                  continue;
                }
              }

              if (!authorization.isUnauthorizeable() && triedReauthorization++ < 3) {
                authorization = authorizatonHandler.reauthorize(uri, authorization);
                if (authorization.isAuthorized()) {
                  --i;
                  continue;
                }
              }
            }
          }
        }

        if (!CacheHandling.CACHE_IGNORE.equals(cacheHandling)
            && uriConverter.exists(cacheURI, options)
            && (!(transferListener.exception instanceof IncomingFileTransferException)
                || ((IncomingFileTransferException) transferListener.exception).getErrorCode()
                    != HttpURLConnection.HTTP_NOT_FOUND)) {
          setExpectedETag(uri, transferListener.eTag == null ? eTag : transferListener.eTag);
          return uriConverter.createInputStream(cacheURI, options);
        }

        throw new IOExceptionWithCause(transferListener.exception);
      }

      byte[] bytes = transferListener.out.toByteArray();

      // In the case of the Github API, the bytes will be JSON that contains a "content" pair
      // containing the Base64 encoding of the actual contents.
      if (API_GITHUB_HOST.equals(getHost(uri))) {
        // Find the start tag in the JSON value.
        String value = new String(bytes, "UTF-8");
        int start = value.indexOf(CONTENT_TAG);
        if (start != -1) {
          // Find the ending quote of the encoded contents.
          start += CONTENT_TAG.length();
          int end = value.indexOf('"', start);
          if (end != -1) {
            // The content is delimited by \n so split on that during the conversion.
            String content = value.substring(start, end);
            String[] split = content.split("\\\\n");

            // Write the converted bytes to a new stream and process those bytes instead.
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            for (String line : split) {
              byte[] binary = XMLTypeFactory.eINSTANCE.createBase64Binary(line);
              out.write(binary);
            }

            out.close();
            bytes = out.toByteArray();
          }
        }
      }

      try {
        BaseUtil.writeFile(uriConverter, options, cacheURI, bytes);
      } catch (IORuntimeException ex) {
        // Ignore attempts to write out to the cache file.
        // This may collide with another JVM doing exactly the same thing.
        transferListener.eTag = null;
      } finally {
        setETag(uriConverter, cacheURI, transferListener.eTag);
      }

      setExpectedETag(uri, transferListener.eTag);
      Map<Object, Object> response = getResponse(options);
      if (response != null) {
        response.put(URIConverter.RESPONSE_TIME_STAMP_PROPERTY, transferListener.lastModified);
      }

      ETagMirror etagMirror = (ETagMirror) options.get(ETagMirror.OPTION_ETAG_MIRROR);
      if (etagMirror != null) {
        etagMirror.cacheUpdated(uri);
      }

      return new ByteArrayInputStream(bytes);
    }
  }