public static String decode(String s) {
   try {
     return URLDecoder.decode(s, UTF_8.name());
   } catch (UnsupportedEncodingException e) {
     Logger.getLogger(BasicServlet.class).fatal(UTF_8.name() + " is not a recognized encoding", e);
     throw new AssertionError(e); // can't happen with UTF-8
   }
 }
 protected void assignContent(HttpEntityEnclosingRequestBase request, Map<String, String> params)
     throws UnsupportedEncodingException {
   if (params != null && !params.isEmpty()) {
     List<NameValuePair> pairs = new ArrayList<NameValuePair>(params.size());
     for (Map.Entry<String, String> param : params.entrySet())
       pairs.add(new BasicNameValuePair(param.getKey(), param.getValue()));
     StringEntity entity =
         new StringEntity(URLEncodedUtils.format(pairs, UTF_8.name()), UTF_8.name());
     entity.setContentType(CONTENT_TYPE_WWW_FORM_URLENCODED);
     request.setEntity(entity);
   }
 }
 public String readFully() {
   StringBuilder stringBuilder = new StringBuilder();
   while (hasNext()) {
     stringBuilder.append(UTF_8.decode(next().content()));
   }
   return stringBuilder.toString();
 }
 @Override
 public String format(
     String projectName,
     String path,
     String revision,
     String abbrRev,
     ConfigSection cfg,
     InputStream raw)
     throws IOException {
   // Docx4J tries to load some resources dynamically. This fails if the Gerrit
   // core classloader is used since it doesn't see the resources that are
   // contained in the plugin jar. To make the resource loading work we
   // must set a context classloader on the current thread.
   ClassLoader loader = Thread.currentThread().getContextClassLoader();
   try {
     Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
     WordprocessingMLPackage p = Docx4J.load(raw);
     HTMLSettings htmlSettings = Docx4J.createHTMLSettings();
     htmlSettings.setWmlPackage(p);
     Docx4jProperties.setProperty("docx4j.Convert.Out.HTML.OutputMethodXML", true);
     try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
       Docx4J.toHTML(htmlSettings, out, Docx4J.FLAG_EXPORT_PREFER_XSL);
       String html = out.toString(UTF_8.name());
       return util.applyCss(html, NAME, projectName);
     }
   } catch (Docx4JException e) {
     throw new IOException(e);
   } finally {
     Thread.currentThread().setContextClassLoader(loader);
   }
 }
Beispiel #5
0
 private String createQuery(String url, Map<String, String> params) throws QiitaException {
   StringBuilder sb = new StringBuilder(url);
   if (url.contains("?")) {
     sb.append('&');
   } else {
     sb.append('?');
   }
   try {
     for (Entry<String, String> entry : params.entrySet()) {
       String key = URLEncoder.encode(entry.getKey(), UTF_8.name());
       String value = URLEncoder.encode(entry.getValue(), UTF_8.name());
       sb.append(key).append('=').append(value).append('&');
     }
   } catch (UnsupportedEncodingException e) {
     throw new QiitaException(e);
   }
   return sb.delete(sb.length() - 1, sb.length()).toString();
 }
 // FIXME Get a 302 in France...
 @Test(groups = "online", enabled = false)
 public void testUrlRequestParametersEncoding() throws Exception {
   try (AsyncHttpClient client = asyncHttpClient()) {
     String requestUrl2 = URL + URLEncoder.encode(REQUEST_PARAM, UTF_8.name());
     logger.info(String.format("Executing request [%s] ...", requestUrl2));
     Response response = client.prepareGet(requestUrl2).execute().get();
     assertEquals(response.getStatusCode(), 302);
   }
 }
Beispiel #7
0
 @Test
 public void listCacheNamesTextList() throws Exception {
   RestResponse r = adminSession.get("/config/server/caches/?format=TEXT_LIST");
   assertThat(r.getStatusCode()).isEqualTo(HttpStatus.SC_OK);
   String result = new String(Base64.decode(r.getEntityContent()), UTF_8.name());
   List<String> list = Arrays.asList(result.split("\n"));
   assertThat(list).contains("accounts");
   assertThat(list).contains("projects");
   assertThat(Ordering.natural().isOrdered(list)).isTrue();
 }
 protected String readLogFully(final ClientResponse logs) throws IOException {
   final LogReader logReader = new LogReader(logs.getEntityInputStream());
   StringBuilder stringBuilder = new StringBuilder();
   LogMessage logMessage;
   while ((logMessage = logReader.nextMessage()) != null) {
     stringBuilder.append(UTF_8.decode(logMessage.content()));
   }
   logReader.close();
   return stringBuilder.toString();
 }
 private HttpGet createGetRequest(String urlStr, Map<String, String> params) {
   StringBuilder bld = new StringBuilder(createURI(urlStr));
   if (params != null && !params.isEmpty()) {
     List<BasicNameValuePair> pairs = new ArrayList<BasicNameValuePair>();
     for (Map.Entry<String, String> param : params.entrySet())
       pairs.add(new BasicNameValuePair(param.getKey(), param.getValue()));
     bld.append('?');
     bld.append(URLEncodedUtils.format(pairs, UTF_8.name()));
   }
   return new HttpGet(URI.create(bld.toString()));
 }
Beispiel #10
0
 private void setFormValue(HttpEntityEnclosingRequestBase request, Map<String, String> params)
     throws QiitaException {
   List<NameValuePair> nameValuePairs = new ArrayList<>();
   for (Entry<String, String> entry : params.entrySet()) {
     nameValuePairs.add(new BasicNameValuePair(entry.getKey(), entry.getValue()));
   }
   try {
     request.setEntity(new UrlEncodedFormEntity(nameValuePairs, UTF_8.name()));
   } catch (UnsupportedEncodingException e) {
     throw new QiitaException(e);
   }
 }
Beispiel #11
0
 @Description("unescape a URL-encoded string")
 @ScalarFunction
 @LiteralParameters("x")
 @SqlType("varchar(x)")
 public static Slice urlDecode(@SqlType("varchar(x)") Slice value) {
   try {
     return slice(URLDecoder.decode(value.toStringUtf8(), UTF_8.name()));
   } catch (UnsupportedEncodingException e) {
     throw new AssertionError(e);
   } catch (IllegalArgumentException e) {
     throw new PrestoException(INVALID_FUNCTION_ARGUMENT, e);
   }
 }
  private void showDoc(
      HttpServletRequest req,
      HttpServletResponse res,
      GitilesView view,
      MarkdownConfig cfg,
      MarkdownToHtml.Builder fmt,
      MarkdownFile navFile,
      MarkdownFile srcFile)
      throws IOException {
    Map<String, Object> data = new HashMap<>();
    Navbar navbar = new Navbar();
    if (navFile != null) {
      navbar.setFormatter(fmt.setFilePath(navFile.path).build());
      navbar.setMarkdown(navFile.content);
    }
    data.putAll(navbar.toSoyData());

    Node doc = GitilesMarkdown.parse(srcFile.content);
    data.put("pageTitle", pageTitle(doc, srcFile));
    if (view.getType() != GitilesView.Type.ROOTED_DOC) {
      data.put("sourceUrl", GitilesView.show().copyFrom(view).toUrl());
      data.put("logUrl", GitilesView.log().copyFrom(view).toUrl());
      data.put("blameUrl", GitilesView.blame().copyFrom(view).toUrl());
    }
    if (cfg.analyticsId != null) {
      data.put("analyticsId", cfg.analyticsId);
    }
    data.put("bodyHtml", fmt.setFilePath(srcFile.path).build().toSoyHtml(doc));

    String page = renderer.render(SOY_TEMPLATE, data);
    byte[] raw = page.getBytes(UTF_8);
    res.setContentType(FormatType.HTML.getMimeType());
    res.setCharacterEncoding(UTF_8.name());
    setCacheHeaders(res);
    if (acceptsGzipEncoding(req)) {
      res.addHeader(HttpHeaders.VARY, HttpHeaders.ACCEPT_ENCODING);
      res.setHeader(HttpHeaders.CONTENT_ENCODING, "gzip");
      raw = gzip(raw);
    }
    res.setContentLength(raw.length);
    res.setStatus(HttpServletResponse.SC_OK);
    res.getOutputStream().write(raw);
  }
Beispiel #13
0
    /**
     * Execute an HTTP request.
     *
     * @return HTTP response object of specified {@code type}.
     * @throws RetrofitError Thrown if any error occurs during the HTTP request.
     */
    private Object invokeRequest(RestMethodInfo methodDetails, Object[] args) {
      methodDetails.init(); // Ensure all relevant method information has been loaded.

      String url = server.getUrl();
      try {
        Request request =
            new RequestBuilder(converter) //
                .setApiUrl(server.getUrl())
                .setArgs(args)
                .setHeaders(headers.get())
                .setMethodInfo(methodDetails)
                .build();
        url = request.getUrl();

        if (!methodDetails.isSynchronous) {
          // If we are executing asynchronously then update the current thread with a useful name.
          Thread.currentThread().setName(THREAD_PREFIX + url);
        }

        if (LOGGER.isLoggable(Level.FINE)) {
          logRequest(request);
        }

        Object profilerObject = null;
        if (profiler != null) {
          profilerObject = profiler.beforeCall();
        }

        long start = System.nanoTime();
        Response response = clientProvider.get().execute(request);
        long elapsedTime = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - start);

        int statusCode = response.getStatus();
        if (profiler != null) {
          RequestInformation requestInfo = getRequestInfo(server, methodDetails, request);
          profiler.afterCall(requestInfo, elapsedTime, statusCode, profilerObject);
        }

        TypedInput body = response.getBody();
        if (LOGGER.isLoggable(Level.FINE)) {
          // Replace the response since the logger needs to consume the entire input stream.
          body = logResponse(url, response.getStatus(), body, elapsedTime);
        }

        List<Header> headers = response.getHeaders();
        for (Header header : headers) {
          if (HTTP.CONTENT_TYPE.equalsIgnoreCase(header.getName()) //
              && !UTF_8.equalsIgnoreCase(Utils.parseCharset(header.getValue()))) {
            throw new IOException("Only UTF-8 charset supported.");
          }
        }

        Type type = methodDetails.type;
        if (statusCode >= 200 && statusCode < 300) { // 2XX == successful request
          if (type.equals(Response.class)) {
            return response;
          }
          if (body == null) {
            return null;
          }
          try {
            return converter.fromBody(body, type);
          } catch (ConversionException e) {
            throw RetrofitError.conversionError(url, response, converter, type, e);
          }
        }
        throw RetrofitError.httpError(url, response, converter, type);
      } catch (RetrofitError e) {
        throw e; // Pass through our own errors.
      } catch (IOException e) {
        throw RetrofitError.networkError(url, e);
      } catch (Throwable t) {
        throw RetrofitError.unexpectedError(url, t);
      }
    }
 private static StringEntity jsonStringEntity(String json) {
   return new StringEntity(json, UTF_8.name());
 }
  @Override
  public final RequestLine parse(final ByteBuffer buffer) {
    // mark the current position of the buffer
    // if the parse is not complete, we will rewind to the mark()ed position
    offset = buffer.position();
    while (buffer.hasRemaining()) {
      switch (stateStack.peek()) {
        case METHOD:
          byte c = buffer.get();
          if (isTokenChar(c)) {
            // valid char for HTTP method
            continue;
          } else if (c == ' ') {
            int length = buffer.position() - offset;
            String s =
                new String(buffer.array(), buffer.arrayOffset() + offset, --length, US_ASCII);
            this.method = Method.parse(s);
            offset = buffer.position();
            stateStack.pop();
          } else {
            throw new IllegalArgumentException(
                String.format("Illegal character '%s' in %s", (char) c, stateStack.peek()));
          }
          break;

        case REQUEST_URI:
          switch (buffer.get()) {
            case ' ':
              int length = buffer.position() - offset;
              String s =
                  new String(buffer.array(), buffer.arrayOffset() + offset, --length, US_ASCII);
              try {
                this.url = URLDecoder.decode(s, UTF_8.displayName());
              } catch (UnsupportedEncodingException e) {
                throw new IllegalArgumentException(e);
              }
              offset = buffer.position();
              stateStack.pop();
              break;

            default:
              break;
          }
          break;

        case HTTP_VERSION:
          final byte p = buffer.get();
          switch (p) {
            case '\r':
              int length = buffer.position() - offset;
              String s =
                  new String(buffer.array(), buffer.arrayOffset() + offset, --length, US_ASCII);
              this.version = Version.parse(s);
              offset = buffer.position();
              stateStack.pop();
              break;

            case 'H':
            case 'T':
            case 'P':
            case '/':
            case '0':
            case '1':
            case '9':
            case '.':
              // valid char for HTTP Version
              break;

            default:
              throw new IllegalArgumentException(
                  String.format("Illegal character '%s' in %s", (char) p, stateStack.peek()));
          }
          break;

        case REQUEST_LINE_END:
          switch (buffer.get()) {
            case '\n':
              try {
                return new RequestLine(method, url, version);
              } catch (URISyntaxException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
              }

            default:
              throw new IllegalArgumentException("\\n was not encountered");
          }
      }
    }
    buffer.position(offset);
    return null;
  }
 public void setBody(final String body) {
   this.body = (body != null) ? body.getBytes(Charset.forName(UTF_8.name())) : null;
   isBinaryBody = false;
 }
 public String getBody() {
   return (!isBinaryBody && body != null) ? new String(body, Charset.forName(UTF_8.name())) : null;
 }
 public ResponseDefinition(final int statusCode, final String bodyContent) {
   this.status = statusCode;
   this.body = (bodyContent == null) ? null : bodyContent.getBytes(Charset.forName(UTF_8.name()));
 }
Beispiel #19
0
public class ChmConstants {
  /* Prevents instantiation */
  private ChmConstants() {}

  public static final String DEFAULT_CHARSET = UTF_8.name();
  public static final String ITSF = "ITSF";
  public static final String ITSP = "ITSP";
  public static final String PMGL = "PMGL";
  public static final String LZXC = "LZXC";
  public static final String CHM_PMGI_MARKER = "PMGI";
  public static final int BYTE_ARRAY_LENGHT = 16;
  public static final int CHM_ITSF_V2_LEN = 0x58;
  public static final int CHM_ITSF_V3_LEN = 0x60;
  public static final int CHM_ITSP_V1_LEN = 0x54;
  public static final int CHM_PMGL_LEN = 0x14;
  public static final int CHM_PMGI_LEN = 0x08;
  public static final int CHM_LZXC_RESETTABLE_V1_LEN = 0x28;
  public static final int CHM_LZXC_MIN_LEN = 0x18;
  public static final int CHM_LZXC_V2_LEN = 0x1c;
  public static final int CHM_SIGNATURE_LEN = 4;
  public static final int CHM_VER_2 = 2;
  public static final int CHM_VER_3 = 3;
  public static final int CHM_VER_1 = 1;
  public static final int CHM_WINDOW_SIZE_BLOCK = 0x8000;

  /* my hacking */
  public static final int START_PMGL = 0xCC;
  public static final String CONTROL_DATA = "ControlData";
  public static final String RESET_TABLE = "ResetTable";
  public static final String CONTENT = "Content";

  /* some constants defined by the LZX specification */
  public static final int LZX_MIN_MATCH = 2;
  public static final int LZX_MAX_MATCH = 257;
  public static final int LZX_NUM_CHARS = 256;
  public static final int LZX_BLOCKTYPE_INVALID = 0; /*
                                                        * also blocktypes 4-7
                                                        * invalid
                                                        */
  public static final int LZX_BLOCKTYPE_VERBATIM = 1;
  public static final int LZX_BLOCKTYPE_ALIGNED = 2;
  public static final int LZX_BLOCKTYPE_UNCOMPRESSED = 3;
  public static final int LZX_PRETREE_NUM_ELEMENTS_BITS = 4; /* ??? */
  public static final int LZX_PRETREE_NUM_ELEMENTS = 20;
  public static final int LZX_ALIGNED_NUM_ELEMENTS = 8; /*
                                                           * aligned offset tree
                                                           * #elements
                                                           */
  public static final int LZX_NUM_PRIMARY_LENGTHS = 7; /*
                                                          * this one missing
                                                          * from spec!
                                                          */
  public static final int LZX_NUM_SECONDARY_LENGTHS = 249; /*
                                                              * length tree
                                                              * #elements
                                                              */

  /* LZX huffman defines: tweak tablebits as desired */
  public static final int LZX_PRETREE_MAXSYMBOLS = LZX_PRETREE_NUM_ELEMENTS;
  public static final int LZX_PRETREE_TABLEBITS = 6;
  public static final int LZX_MAINTREE_MAXSYMBOLS = LZX_NUM_CHARS + 50 * 8;
  public static final int LZX_MAIN_MAXSYMBOLS = LZX_NUM_CHARS * 2;
  public static final int LZX_MAINTREE_TABLEBITS = 12;
  public static final int LZX_LENGTH_MAXSYMBOLS = LZX_NUM_SECONDARY_LENGTHS + 1;
  public static final int LZX_LENGTH_TABLEBITS = 12;
  public static final int LZX_ALIGNED_MAXSYMBOLS = LZX_ALIGNED_NUM_ELEMENTS;
  public static final int LZX_ALIGNED_TABLEBITS = 7;
  public static final int LZX_LENTABLE_SAFETY = 64;

  public static short[] EXTRA_BITS = {
    0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13,
    13, 14, 14, 15, 15, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17
  };

  public static int[] POSITION_BASE = {
    0, 1, 2, 3, 4, 6, 8, 12, 16, 24, 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, 1024, 1536, 2048,
    3072, 4096, 6144, 8192, 12288, 16384, 24576, 32768, 49152, 65536, 98304, 131072, 196608, 262144,
    393216, 524288, 655360, 786432, 917504, 1048576, 1179648, 1310720, 1441792, 1572864, 1703936,
    1835008, 1966080, 2097152
  };
}
Beispiel #20
0
 public String content() {
   if (content == null) {
     return null;
   }
   return new String(content, Charset.forName(UTF_8.name()));
 }