Java Code Examples for com.google.common.io.CharStreams#toString()

private int countKmsProcesses() {
  int result = 0;
  try {
    // This command counts number of process (given its PID, stored in
    // kms-pid file)

    if (isKmsRemote) {
      String kmsPid = remoteKmsSshConnection.execAndWaitCommandNoBr("cat",
          remoteKmsSshConnection.getTmpFolder() + "/kms-pid");
      result = Integer.parseInt(remoteKmsSshConnection
          .execAndWaitCommandNoBr("ps --pid " + kmsPid + " --no-headers | wc -l"));
    } else {
      String[] command = { "sh", "-c",
          "ps --pid `cat " + workspace + File.separator + "kms-pid` --no-headers | wc -l" };
      Process countKms = Runtime.getRuntime().exec(command);
      String stringFromStream =
          CharStreams.toString(new InputStreamReader(countKms.getInputStream(), "UTF-8"));
      result = Integer.parseInt(stringFromStream.trim());
    }
  } catch (IOException e) {
    log.warn("Exception counting KMS processes", e);
  }

  return result;
}
 

private String readGceMetadata(String path) {
  String value = "";
  HttpURLConnection connection = connectionFactory.apply(path);
  try {
    connection.connect();
    int responseCode = connection.getResponseCode();
    if (responseCode < 200 || responseCode > 299) {
      logger.atWarning().log(
          "Got an error response: %d\n%s",
          responseCode,
          CharStreams.toString(new InputStreamReader(connection.getErrorStream(), UTF_8)));
    } else {
      value = CharStreams.toString(new InputStreamReader(connection.getInputStream(), UTF_8));
    }
  } catch (IOException e) {
    logger.atWarning().withCause(e).log("Cannot obtain GCE metadata from path %s", path);
  }
  return value;
}
 

protected void readNodeModel(StorageAwareResource resource, InputStream inputStream) throws IOException {
	SerializableNodeModel serializableNodeModel = new SerializableNodeModel(resource);
	// if this is a synthetic resource (i.e. tests or so, don't load the node model)
	if (!resource.getResourceSet().getURIConverter().exists(resource.getURI(),
			resource.getResourceSet().getLoadOptions())) {
		LOG.info("Skipping loading node model for synthetic resource " + resource.getURI());
		return;
	}
	String completeContent = CharStreams.toString(
			new InputStreamReader(resource.getResourceSet().getURIConverter().createInputStream(resource.getURI()),
					resource.getEncoding()));
	DeserializationConversionContext deserializationContext = new DeserializationConversionContext(resource,
			completeContent);
	serializableNodeModel.readObjectData(new DataInputStream(inputStream), deserializationContext);
	resource.setParseResult(new ParseResult(head(resource.getContents()), serializableNodeModel.root,
			deserializationContext.hasErrors()));
}
 

@Override
public void performFinalAction(JCommander parser) throws CommandException {
    if (!definitionStdIn && null == definitionFile) {
        throw new ExitWithCodeException(1, "API definition must be provided", true);
    }

    // read definition from STDIN or file
    String definition;
    try (InputStream is = (definitionStdIn ? System.in : Files.newInputStream(definitionFile))) {
        definition = CharStreams.toString(new InputStreamReader(is));

    } catch (IOException e) {
        throw new CommandException(e);
    }

    LOGGER.debug("Adding definition to API '{}' with contents: {}", this::getModelName, () -> definition);

    ManagementApiUtil.invokeAndCheckResponse(() ->
            getManagerConfig().buildServerApiClient(VersionAgnosticApi.class, serverVersion).setDefinition(orgName, name, version, definitionType, new TypedString(definition)));
}
 

void updateBuildProperties(XpandExecutionContext ctx) throws Exception {
	if (!updateBuildProperties || modelPluginID != null)
		return;
	Outlet rootOutlet = ctx.getOutput().getOutlet(org.eclipse.xtext.generator.Generator.PLUGIN_RT);
	Outlet modelOutlet = ctx.getOutput().getOutlet(org.eclipse.xtext.generator.Generator.MODEL);
	String buildPropertiesPath = rootOutlet.getPath() + "/build.properties";
	String modelPath = modelOutlet.getPath().substring(rootOutlet.getPath().length() + 1) + "/";
	Properties buildProperties = new Properties();
	Reader reader = new InputStreamReader(new FileInputStream(new File(buildPropertiesPath)), Charset.forName(rootOutlet.getFileEncoding()));
	try {
		String existingContent = CharStreams.toString(reader);
		// for encoding details, see Properties.load
		buildProperties.load(new StringInputStream(existingContent, "ISO-8859-1"));
		String binIncludes = buildProperties.getProperty("bin.includes");
		boolean changed = false;
		if (binIncludes == null) {
			existingContent += "bin.includes = " + modelPath + Strings.newLine()+ "               ";
			changed = true;
		} else if (!binIncludes.contains(modelPath)) {
			existingContent = existingContent.replace("bin.includes = ", "bin.includes = " + modelPath + ",\\" + Strings.newLine() +"               ");
			changed = true;
		}
		if (changed) {
			Writer writer = new OutputStreamWriter(new FileOutputStream(new File(buildPropertiesPath)), Charset.forName(rootOutlet.getFileEncoding()));
			writer.write(existingContent);
			writer.close();
		}
	} finally {
		reader.close();
	}
}
 

private String sqlFileAsString(String sqlFile) throws Exception {
  String contents;

  FileSystem fs = FileSystem.get(new URI(sqlFile), new Configuration());
  InputStream stream = fs.open(new Path(sqlFile));
  InputStreamReader reader = new InputStreamReader(stream, Charsets.UTF_8);
  contents = CharStreams.toString(reader);
  reader.close();
  stream.close();

  return contents;
}
 

/** If the response code is 200, returns the content at the URL. Otherwise, returns null. */
public static String getUrlContent(String url) {
  try {
    HttpURLConnection urlConnection = (HttpURLConnection) new URL(url).openConnection();
    int responseCode = urlConnection.getResponseCode();
    if (responseCode == 200) {
      return CharStreams.toString(new InputStreamReader(urlConnection.getInputStream()));
    }
  } catch (IOException e) {
  }
  return null;
}
 

protected void processPostRequest(HttpServletRequest request, HttpServletResponse response) {
    
    if ((request == null) || (response == null)) {
        return;
    }
    
    long metricsReceivedTimestampInMilliseconds = System.currentTimeMillis();
    
    PrintWriter out = null;
    
    try {
        response.setContentType("text/json"); 
        
        String username = request.getParameter("u");
        String password = request.getParameter("p");
        String timePrecision = request.getParameter("time_precision");
        String httpAuth = request.getHeader("Authorization");

        String json = CharStreams.toString(request.getReader());
        
        String requestUri = request.getRequestURI();
        String database = (requestUri == null) ? null : StringUtils.substringBetween(requestUri, "/db/", "/series");

        parseMetrics(database, json, username, password, httpAuth, timePrecision, GlobalVariables.influxdbPrefix, metricsReceivedTimestampInMilliseconds);

        out = response.getWriter();
    }
    catch (Exception e) {
        logger.error(e.toString() + System.lineSeparator() + StackTrace.getStringFromStackTrace(e));
    }
    finally {            
        if (out != null) {
            out.close();
        }
    }
}
 

public CommandScriptLoader() throws IOException {
    this.engine = new NashornCraftScriptEngine();

    try (InputStream inputStream = Fawe.class.getResourceAsStream("/cs_adv.js")) {
        this.loader = CharStreams.toString(new InputStreamReader(inputStream, Charsets.UTF_8));
    }
}
 

private void copyDtaFile(String templateName, Path destFile, Map<String, String> mapping) throws IOException {
    try (final Reader reader = new InputStreamReader(getClass().getResourceAsStream(templateName))) {
        String dtaContents = CharStreams.toString(reader);
        dtaContents = mapping.keySet().stream()
                .reduce(dtaContents, (str, key) -> str.replaceAll(key, mapping.get(key)));
        try (BufferedWriter writer = Files.newBufferedWriter(destFile)) {
            writer.write(dtaContents);
        }
    }
}
 

@Provides
@Payload
static String providePayloadAsString(HttpServletRequest req) {
  try {
    return CharStreams.toString(req.getReader());
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

private String readStreamToString(final InputStream in) throws IOException {
  try {
    return CharStreams.toString(new InputStreamReader(in, UTF_8));
  }
  finally {
    in.close();
  }
}
 

public ActionForward addPeople(ActionMapping mapping, ActionForm form, HttpServletRequest request,
        HttpServletResponse response) throws Exception {
    final CerimonyInquiry cerimonyInquiry = getDomainObject(request, "cerimonyInquiryId");
    final UsernameFileBean usernameFileBean = getRenderedObject();
    final String contents =
            CharStreams.toString(new InputStreamReader(usernameFileBean.getInputStream(), Charset.defaultCharset()));
    final Set<String> usernames = findUsernames(contents);
    cerimonyInquiry.addPeople(usernames);
    return forwardToInquiry(mapping, request, "viewAlumniCerimonyInquiry", cerimonyInquiry);
}
 

private String exec(final String command) {
  try {
    final Process process = Runtime.getRuntime().exec(command);
    return CharStreams.toString(new InputStreamReader(process.getInputStream(), UTF_8));
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
}
 

private String doRequest(String url, String method, List<Pair<String, ?>> parameters)
    throws IOException, ServerException, ForbiddenException, NotFoundException,
        UnauthorizedException, BadRequestException {
  final String authToken = EnvironmentContext.getCurrent().getSubject().getToken();
  final boolean hasQueryParams = parameters != null && !parameters.isEmpty();
  if (hasQueryParams) {
    final UriBuilder ub = UriBuilder.fromUri(url);
    for (Pair<String, ?> parameter : parameters) {
      ub.queryParam(parameter.first, parameter.second);
    }
    url = ub.build().toString();
  }
  final HttpURLConnection conn = (HttpURLConnection) new URL(url).openConnection();
  conn.setConnectTimeout(60000);
  conn.setReadTimeout(60000);

  try {
    conn.setRequestMethod(method);
    // drop a hint for server side that we want to receive application/json
    conn.addRequestProperty(HttpHeaders.ACCEPT, MediaType.APPLICATION_JSON);
    if (authToken != null) {
      conn.setRequestProperty(HttpHeaders.AUTHORIZATION, "bearer " + authToken);
    }
    final int responseCode = conn.getResponseCode();
    if ((responseCode / 100) != 2) {
      InputStream in = conn.getErrorStream();
      if (in == null) {
        in = conn.getInputStream();
      }
      final String str;
      try (Reader reader = new InputStreamReader(in)) {
        str = CharStreams.toString(reader);
      }
      final String contentType = conn.getContentType();
      if (contentType != null
          && (contentType.startsWith(MediaType.APPLICATION_JSON)
              || contentType.startsWith("application/vnd.api+json"))) {
        final KeycloakErrorResponse serviceError =
            DtoFactory.getInstance().createDtoFromJson(str, KeycloakErrorResponse.class);
        if (responseCode == Response.Status.FORBIDDEN.getStatusCode()) {
          throw new ForbiddenException(serviceError.getErrorMessage());
        } else if (responseCode == Response.Status.NOT_FOUND.getStatusCode()) {
          throw new NotFoundException(serviceError.getErrorMessage());
        } else if (responseCode == Response.Status.UNAUTHORIZED.getStatusCode()) {
          throw new UnauthorizedException(serviceError.getErrorMessage());
        } else if (responseCode == Response.Status.INTERNAL_SERVER_ERROR.getStatusCode()) {
          throw new ServerException(serviceError.getErrorMessage());
        } else if (responseCode == Response.Status.BAD_REQUEST.getStatusCode()) {
          throw new BadRequestException(serviceError.getErrorMessage());
        }
        throw new ServerException(serviceError.getErrorMessage());
      }
      // Can't parse content as json or content has format other we expect for error.
      throw new IOException(
          String.format(
              "Failed access: %s, method: %s, response code: %d, message: %s",
              UriBuilder.fromUri(url).replaceQuery("token").build(), method, responseCode, str));
    }
    try (Reader reader = new InputStreamReader(conn.getInputStream())) {
      return CharStreams.toString(reader);
    }
  } finally {
    conn.disconnect();
  }
}
 

@Override
public void execute() throws MojoExecutionException {

  if ("pom".equals(project.getPackaging())) {
    getLog().info("Project packaging is POM, skipping...");
    return;
  }

  if (skip) {
    getLog().info("Skipping source reformatting due to plugin configuration.");
    return;
  }

  try {
    Set<File> sourceFiles = new HashSet<>();

    if (formatMain) {
      sourceFiles.addAll(findFilesToReformat(sourceDirectory, outputDirectory));
    }
    if (formatTest) {
      sourceFiles.addAll(findFilesToReformat(testSourceDirectory, testOutputDirectory));
    }

    Set<File> sourceFilesToProcess = filterModified ? filterUnchangedFiles(sourceFiles) : sourceFiles;

    JavaFormatterOptions options = getJavaFormatterOptions();

    for (File file : sourceFilesToProcess) {
      String source = CharStreams.toString(new InputStreamReader(new FileInputStream(file), StandardCharsets.UTF_8));

      Formatter formatter = new Formatter(options);
      String formattedSource = fixImports ? formatter.formatSourceAndFixImports(source) : formatter.formatSource(source);

      HashCode sourceHash = Hashing.sha256().hashString(source, StandardCharsets.UTF_8);
      HashCode formattedHash = Hashing.sha256().hashString(formattedSource, StandardCharsets.UTF_8);

      if (!formattedHash.equals(sourceHash)) {
        // overwrite existing file
        Files.write(file.toPath(), formattedSource.getBytes(StandardCharsets.UTF_8), StandardOpenOption.WRITE, StandardOpenOption.TRUNCATE_EXISTING);

        getLog().info(String.format("Reformatted file %s", file.getPath()));
      }
    }
  } catch (Exception e) {
    throw new MojoExecutionException(e.getMessage(), e);
  }
}
 

@Test
public void testTraverseNotIncrementalCommonAcl() throws Exception {
  // target targetItems
  int numberOfItems = 5;
  Map<String, String> targetItems = new HashMap<>();
  List<ApiOperation> docs = new ArrayList<>();
  for (int i = 0; i < numberOfItems; i++) {
    String id = "Test" + i;
    String content = "Test content " + i;
    targetItems.put(id, content);
    Item item = new Item();
    item.setName(id);
    docs.add(
        new RepositoryDoc.Builder()
            .setItem(item)
            .setRequestMode(RequestMode.ASYNCHRONOUS)
            .setContent(ByteArrayContent.fromString("text/html", content), ContentFormat.HTML)
            .build());
  }

  // DefaultAcl
  doAnswer(
      invocation -> {
        SettableFuture<Operation> result = SettableFuture.create();
        result.set(new Operation().setDone(true));
        return result;
      })
      .when(indexingServiceMock)
      .indexItem(
          argThat(item -> item.getName().equals(DefaultAcl.DEFAULT_ACL_NAME_DEFAULT)),
          eq(RequestMode.SYNCHRONOUS));
  // Documents
  SettableFuture<Item> updateFuture = SettableFuture.create();
  doAnswer(
      invocation -> {
        updateFuture.set(new Item());
        return updateFuture;
      })
      .when(indexingServiceMock)
      .indexItemAndContent(
          any(), any(), any(), eq(ContentFormat.HTML), eq(RequestMode.ASYNCHRONOUS));
  when(repositoryMock.getAllDocs(null))
      .thenReturn(new CheckpointCloseableIterableImpl.Builder<>(docs).build());
  // Delete other queue
  SettableFuture<Operation> deleteQueueFuture = SettableFuture.create();
  deleteQueueFuture.set(new Operation().setDone(true));
  when(indexingServiceMock.deleteQueueItems(any())).thenReturn(deleteQueueFuture);

  // full traversal test
  FullTraversalConnector connector =
      new FullTraversalConnector(repositoryMock, checkpointHandlerMock);

  setConfig("0", DefaultAclChoices.COMMON);

  connector.init(connectorContextMock);
  connector.traverse();

  InOrder inOrderCheck = inOrder(indexingServiceMock);
  // one update item with content for each of five targetItems in the db
  inOrderCheck
      .verify(indexingServiceMock, times(numberOfItems))
      .indexItemAndContent(
          itemListCaptor.capture(),
          contentCaptor.capture(),
          eq(null),
          eq(ContentFormat.HTML),
          eq(RequestMode.ASYNCHRONOUS));
  List<Item> allItems = itemListCaptor.getAllValues();
  List<ByteArrayContent> allContent = contentCaptor.getAllValues();
  assertEquals(allItems.size(), numberOfItems);
  for (int i = 0; i < numberOfItems; i++) {
    assertThat(targetItems.keySet(), hasItem(allItems.get(i).getName())); // verify item
    String html =
        CharStreams.toString(
            new InputStreamReader(allContent.get(i).getInputStream(), UTF_8));
    assertEquals(html, targetItems.get(allItems.get(i).getName())); // verify content
    ItemAcl acl = allItems.get(i).getAcl();
    assertEquals(DefaultAcl.DEFAULT_ACL_NAME_DEFAULT, acl.getInheritAclFrom());
    assertEquals(InheritanceType.PARENT_OVERRIDE.name(), acl.getAclInheritanceType());
  }
}
 

static String convertStreamToString(InputStream stream, String charset) throws IOException {
  String result = CharStreams.toString(new InputStreamReader(stream, charset));
  return result;
}
 

public void doPost(HttpServletRequest req, HttpServletResponse resp) {
    logger.debug("Handling json request");

    GoTimer methodTimer = null;
    String methodName = null;
    Span span = null;
    long startTime = System.nanoTime();
    Map<String, String> headers = gatherHttpHeaders(req);
    OrangeContext context = new OrangeContext(headers);
    try {

        MDC.put(CORRELATION_ID, context.getCorrelationId());

        String postedContent = CharStreams.toString(req.getReader());
        logger.debug("Request JSON: {}", postedContent);

        JsonRpcRequest rpcRequest;

        try {
            rpcRequest = parseRpcRequest(postedContent);
        } catch (IllegalArgumentException iaex) {
            logger.warn("Error parsing request: " + postedContent, iaex);
            @SuppressWarnings("ThrowableNotThrown")
            RpcCallException callException = new RpcCallException(RpcCallException.Category.BadRequest,
                    iaex.getMessage());
            JsonObject jsonResponse = new JsonObject();
            jsonResponse.add(ERROR_FIELD, callException.toJson());
            writeResponse(resp, HttpServletResponse.SC_BAD_REQUEST, jsonResponse.toString());
            incrementFailureCounter("unknown", context.getRpcOriginService(),
                    context.getRpcOriginMethod());
            return;
        }

        methodName = rpcRequest.getMethod();

        span = getSpan(methodName, headers, context);

        methodTimer = getMethodTimer(methodName, context.getRpcOriginService(),
                context.getRpcOriginMethod());
        startTime = methodTimer.start();
        context.setCorrelationId(rpcRequest.getIdAsString());
        JsonRpcResponse finalResponse = dispatchJsonRpcRequest(rpcRequest, context);

        resp.setContentType(TYPE_JSON);
        writeResponse(resp, finalResponse.getStatusCode(), finalResponse.toJson().toString());

        //TODO: should we check the response for errors (for metrics)?
        methodTimer.recordSuccess(startTime);
        incrementSuccessCounter(methodName, context.getRpcOriginService(),
                context.getRpcOriginMethod());
    } catch (IOException e) {
        if (span != null) {
            Tags.ERROR.set(span, true);
        }
        //TODO: this case doesn't return a response.  should it?
        methodTimer.recordFailure(startTime);
        logger.error("Error handling request", e);
        incrementFailureCounter(methodName, context.getRpcOriginService(),
                context.getRpcOriginMethod());
    } finally {
        if (span != null) {
            span.finish();
        }
        MDC.remove(CORRELATION_ID);
    }
}
 

protected String getRequestPayload(final StaplerRequest req) throws IOException {
    return CharStreams.toString(req.getReader());
}