Java Code Examples for com.google.common.base.Joiner

public void mark(HeartbeatPulse pulse) {
    // 判断心跳类型是否为checkpoint
    if (!pulse.getPacket().contains(CHECKPOINT_FLAG)) {
        return;
    }

    String key = Joiner.on(".").join(pulse.getSchemaName(), pulse.getTableName());
    logger.debug("mark: {}", key);
    StatMessage message;
    if (!statMessageMap.containsKey(key)) {
        message = new StatMessage(pulse.getDsName(), pulse.getSchemaName(), pulse.getTableName(), STAT_TYPE);
        statMessageMap.put(key, message);
    } else {
        message = statMessageMap.get(key);
    }

    HeartBeatPacket packet = HeartBeatPacket.parse(pulse.getPacket());
    message.setCheckpointMS(packet.getTime());
    message.setTxTimeMS(packet.getTxtime());
    message.setLocalMS(System.currentTimeMillis());
    message.setLatencyMS(message.getLocalMS() - message.getCheckpointMS());
    sender.sendStat(message.toJSONString(), message.getDsName(), message.getSchemaName(), message.getTableName());
    message.cleanUp();
}
 

@NotNull
    private HyperlinkLabel createHyperLink() {
        //JSBundle.message("settings.javascript.root.configurable.name")
        List<String> path = ContainerUtil.newArrayList("HTML", getDisplayName());

        String title = Joiner.on(" / ").join(path);
        final HyperlinkLabel settingsLink = new HyperlinkLabel(title);
        settingsLink.addHyperlinkListener(new HyperlinkAdapter() {
            public void hyperlinkActivated(HyperlinkEvent e) {
//                DataContext dataContext = DataManager.getInstance().getDataContext(settingsLink);
//                OptionsEditor optionsEditor = OptionsEditor.KEY.getData(dataContext);
//                if (optionsEditor == null) {
//                    Project project = CommonDataKeys.PROJECT.getData(dataContext);
//                    if (project != null) {
//                        showSettings(project);
//                    }
//                    return;
//                }
//                Configurable configurable = optionsEditor.findConfigurableById(RTInspection.this.getId());
//                if (configurable != null) {
//                    optionsEditor.clearSearchAndSelect(configurable);
//                }
            }
        });
        return settingsLink;
    }
 

@Override
public void customize(MachineLocation machine) {
    if (!(machine instanceof SshMachineLocation)) {
        throw new IllegalStateException("Machine must be a SshMachineLocation, but got "+machine);
    }
    String file = config.get(FILE_NAME);
    List<String> contents = config.get(CONTENTS);
    checkArgument(Strings.isNonBlank(config.get(FILE_NAME)), "File must be non-empty");
    
    log.info("SetLimitsCustomizer setting limits on "+machine+" in file "+file+" to: "+Joiner.on("; ").join(contents));

    try {
        List<String> cmds = new ArrayList<>();
        for (String content : contents) {
            cmds.add(sudo(String.format("echo \"%s\" | tee -a %s", content, file)));
        }
        exec((SshMachineLocation)machine, true, cmds.toArray(new String[cmds.size()]));
    } catch (Exception e) {
        log.info("SetLimitsCustomizer failed to set limits on "+machine+" (rethrowing)", e);
        throw e;
    }
}
 

@Nullable
@Override
public String getOutputDirectoryName() {
  List<String> components = new ArrayList<>();
  if (!appleSplitCpu.isEmpty()) {
    components.add(applePlatformType.toString().toLowerCase());
    components.add(appleSplitCpu);

    if (options.getMinimumOsVersion() != null) {
      components.add("min" + options.getMinimumOsVersion());
    }
  }
  if (configurationDistinguisher != ConfigurationDistinguisher.UNKNOWN) {
    components.add(configurationDistinguisher.getFileSystemName());
  }

  if (components.isEmpty()) {
    return null;
  }
  return Joiner.on('-').join(components);
}
 

/**
 * Returns the instance identified by the unique name, or throws if it does not exist.
 *
 * @param name represents the name of the {@link FirebaseApp} instance.
 * @return the {@link FirebaseApp} corresponding to the name.
 * @throws IllegalStateException if the {@link FirebaseApp} was not initialized, either via {@link
 *     #initializeApp(FirebaseOptions, String)} or {@link #getApps()}.
 */
public static FirebaseApp getInstance(@NonNull String name) {
  synchronized (appsLock) {
    FirebaseApp firebaseApp = instances.get(normalize(name));
    if (firebaseApp != null) {
      return firebaseApp;
    }

    List<String> availableAppNames = getAllAppNames();
    String availableAppNamesMessage;
    if (availableAppNames.isEmpty()) {
      availableAppNamesMessage = "";
    } else {
      availableAppNamesMessage =
          "Available app names: " + Joiner.on(", ").join(availableAppNames);
    }
    String errorMessage =
        String.format(
            "FirebaseApp with name %s doesn't exist. %s", name, availableAppNamesMessage);
    throw new IllegalStateException(errorMessage);
  }
}
 

@Override
public void write(final InternalRow record) throws IOException {
  String delimitedRow = Joiner.on(",").useForNull("")
    .join(scala.collection.JavaConversions.seqAsJavaList(record.toSeq(schema)));
  try {
    streamingConnection.write(delimitedRow.getBytes(Charset.forName("UTF-8")));
    rowsWritten++;
    if (rowsWritten > 0 && commitAfterNRows > 0 && (rowsWritten % commitAfterNRows == 0)) {
      LOG.info("Committing transaction after rows: {}", rowsWritten);
      streamingConnection.commitTransaction();
      streamingConnection.beginTransaction();
    }
  } catch (StreamingException e) {
    throw new IOException(e);
  }
}
 

private void configureSentryAuthorization(Map<String, String> properties) {
  properties.put("org.apache.sqoop.security.authorization.handler",
      "org.apache.sentry.sqoop.authz.SentryAuthorizationHander");
  properties.put("org.apache.sqoop.security.authorization.access_controller",
      "org.apache.sentry.sqoop.authz.SentryAccessController");
  properties.put("org.apache.sqoop.security.authorization.validator",
      "org.apache.sentry.sqoop.authz.SentryAuthorizationValidator");
  properties.put("org.apache.sqoop.security.authorization.server_name", serverName);
  properties.put("sentry.sqoop.site.url", sentrySite);
  /** set Sentry related jars into classpath */
  List<String> extraClassPath = new LinkedList<String>();
  for (String jar : System.getProperty("java.class.path").split(":")) {
    if ((jar.contains("sentry") || jar.contains("shiro-core") || jar.contains("libthrift"))
        && jar.endsWith("jar")) {
      extraClassPath.add(jar);
    }
  }
  properties.put("org.apache.sqoop.classpath.extra",Joiner.on(":").join(extraClassPath));
}
 

/**
 *
 * @param project
 * @param dir
 * @param executable
 * @param sdk
 * @return
 */
@NotNull
public static List<String> getProjectDisplayInformation(@NotNull Project project, @NotNull File dir, @NotNull String executable, @NotNull Sdk sdk) {
  List<String> strings1 = Collections.EMPTY_LIST;

  if (getInstalledLibraries(sdk).contains(executable)) {
    ArrayList<String> commandLineArguments = new ArrayList<String>();
    commandLineArguments.add(HaxelibCommandUtils.getHaxelibPath(sdk));
    commandLineArguments.add("run");
    commandLineArguments.add(executable);
    commandLineArguments.add("display");
    commandLineArguments.add("flash");

    List<String> strings = HaxelibCommandUtils.getProcessStdout(commandLineArguments,
                                                                dir,
                                                                HaxeSdkUtilBase.getSdkData(sdk));
    String s = Joiner.on("\n").join(strings);
    strings1 = getHXMLFileClasspaths(project, s);
  }

  return strings1;
}
 

private static void updateConnectorIdAnnouncement(Announcer announcer, CatalogName catalogName, InternalNodeManager nodeManager)
{
    //
    // This code was copied from PrestoServer, and is a hack that should be removed when the connectorId property is removed
    //

    // get existing announcement
    ServiceAnnouncement announcement = getPrestoAnnouncement(announcer.getServiceAnnouncements());

    // update connectorIds property
    Map<String, String> properties = new LinkedHashMap<>(announcement.getProperties());
    String property = nullToEmpty(properties.get("connectorIds"));
    Set<String> connectorIds = new LinkedHashSet<>(Splitter.on(',').trimResults().omitEmptyStrings().splitToList(property));
    connectorIds.add(catalogName.toString());
    properties.put("connectorIds", Joiner.on(',').join(connectorIds));

    // update announcement
    announcer.removeServiceAnnouncement(announcement.getId());
    announcer.addServiceAnnouncement(serviceAnnouncement(announcement.getType()).addProperties(properties).build());
    announcer.forceAnnounce();

    nodeManager.refreshNodes();
}
 

/**
 * Asserts that the metric has any (non-default) value for the specified label values.
 *
 * @param labels the labels for which the value is being asserted; the number and order of labels
 *     should match the definition of the metric
 */
public And<S> hasAnyValueForLabels(String... labels) {
  MetricPoint<T> metricPoint = findMetricPointForLabels(ImmutableList.copyOf(labels));
  if (metricPoint == null) {
    failWithBadResults(
        "has a value for labels",
        Joiner.on(':').join(labels),
        "has labeled values",
        Lists.transform(
            Ordering.<MetricPoint<T>>natural().sortedCopy(actual.getTimestampedValues()),
            metricPointConverter));
  }
  if (hasDefaultValue(metricPoint)) {
    failWithBadResults(
        "has a non-default value for labels",
        Joiner.on(':').join(labels),
        "has a value of",
        getMessageRepresentation(metricPoint.value()));
  }
  expectedNondefaultLabelTuples.add(ImmutableList.copyOf(labels));
  return andChainer();
}
 

@Override
public final String toString() {
  StringBuilder sb = new StringBuilder();
  boolean first = true;
  for (SimpleClassTy c : classes()) {
    for (AnnoInfo anno : c.annos()) {
      sb.append(anno);
      sb.append(' ');
    }
    if (!first) {
      sb.append('.');
      sb.append(c.sym().binaryName().substring(c.sym().binaryName().lastIndexOf('$') + 1));
    } else {
      sb.append(c.sym().binaryName().replace('/', '.').replace('$', '.'));
    }
    if (!c.targs().isEmpty()) {
      sb.append('<');
      Joiner.on(',').appendTo(sb, c.targs());
      sb.append('>');
    }
    first = false;
  }
  return sb.toString();
}
 

@Test(dataProvider = "dateArray")
public void testParseArray(Date[] array) throws Exception {
    final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
    String sourceString = "[" + Joiner.on(",").join(Iterables.transform(Arrays.asList(array), new Function<Date, String>() {
        @Override
        public String apply(Date s) {
            return dateFormat.format(s);
        }
    })) + "]";

    byte[] bytes = sourceString.getBytes(StreamUtils.UTF_8);
    ByteFragment fragment = new ByteFragment(bytes, 0, bytes.length);
    Date[] parsedArray = (Date[]) ByteFragmentUtils.parseArray(fragment, Date.class, dateFormat, 1);

    assertEquals(parsedArray.length, array.length);
    for (int i = 0; i < parsedArray.length; i++) {
        assertEquals(parsedArray[i], array[i]);
    }
}
 

@Override
protected Void visitSampledRelation(SampledRelation node, Integer indent) {
  process(node.getRelation(), indent);

  builder.append(" TABLESAMPLE ")
          .append(node.getType())
          .append(" (")
          .append(node.getSamplePercentage())
          .append(')');

  if (node.getColumnsToStratifyOn().isPresent()) {
    builder.append(" STRATIFY ON ")
            .append(" (")
            .append(Joiner.on(",").join(node.getColumnsToStratifyOn().get()));
    builder.append(')');
  }

  return null;
}
 

private static String getMethodType(Method method) {
    Set<String> httpAnnotations = Lists.newArrayList(GET.class, DELETE.class, PUT.class, POST.class, HEAD.class, OPTIONS.class, PATCH.class)
            .stream()
            .filter(httpAnnotation -> method.isAnnotationPresent(httpAnnotation))
            .map(httpAnnotation -> httpAnnotation.getSimpleName())
            .collect(Collectors.toSet());
    return Joiner.on(" ").join(httpAnnotations);
}
 

@Test
public void convert_map_to_querystring_guava() {

	String mapJoined = Joiner.on("&").withKeyValueSeparator("=")
			.join(mapToConvert);

	assertEquals("end-date=2014-11-26&itemsPerPage=25", mapJoined);
}
 

public SanitizeUnknownSolrFields(CommandBuilder builder, Config config, Command parent, Command child, MorphlineContext context) {
  super(builder, config, parent, child, context);      
  
  Config solrLocatorConfig = getConfigs().getConfig(config, "solrLocator");
  SolrLocator locator = new SolrLocator(solrLocatorConfig, context);
  LOG.debug("solrLocator: {}", locator);
  this.schema = locator.getIndexSchema();
  Preconditions.checkNotNull(schema);
  LOG.trace("Solr schema: \n{}", Joiner.on("\n").join(new TreeMap(schema.getFields()).values()));
  
  String str = getConfigs().getString(config, "renameToPrefix", "").trim();
  this.renameToPrefix = str.length() > 0 ? str : null;  
  validateArguments();
}
 

public void batch_mutate(Map<ByteBuffer,Map<String,List<Mutation>>> mutation_map, ConsistencyLevel consistency_level)
throws InvalidRequestException, UnavailableException, TimedOutException
{
    if (startSessionIfRequested())
    {
        Map<String, String> traceParameters = Maps.newLinkedHashMap();
        for (Map.Entry<ByteBuffer, Map<String, List<Mutation>>> mutationEntry : mutation_map.entrySet())
        {
            traceParameters.put(ByteBufferUtil.bytesToHex(mutationEntry.getKey()),
                                Joiner.on(";").withKeyValueSeparator(":").join(mutationEntry.getValue()));
        }
        traceParameters.put("consistency_level", consistency_level.name());
        Tracing.instance.begin("batch_mutate", traceParameters);
    }
    else
    {
        logger.debug("batch_mutate");
    }

    try
    {
        doInsert(consistency_level, createMutationList(consistency_level, mutation_map, true));
    }
    catch (RequestValidationException e)
    {
        throw ThriftConversion.toThrift(e);
    }
    finally
    {
        Tracing.instance.stopSession();
    }
}
 

/**
 * We're not exactly sure why intersection types with the same bounds but in a different order are
 * considered the same type; after all, they can have different erasures. However, the javac
 * implementation behaves that way, so we must as well.
 *
 * <p>The relevant JLS8 sections are 4.4 and 4.9, if any future person wants to go see if they can
 * grok why this behavior is correct.
 */
@Test
public void testIsSameTypeIntersectionTypeDifferentOrder() throws IOException {
  compile(
      Joiner.on('\n')
          .join(
              "class Foo<T extends java.lang.CharSequence & java.lang.Runnable> { }",
              "class Bar<T extends java.lang.Runnable & java.lang.CharSequence> { }"));

  IntersectionType fooType = (IntersectionType) getTypeParameterUpperBound("Foo", 0);
  IntersectionType barType = (IntersectionType) getTypeParameterUpperBound("Bar", 0);

  assertSameType(fooType, barType);
}
 

@Test
public void prepare_DeleteOperationWithIfGiven_ShouldPrepareProperQuery() {
  // Arrange
  String expected =
      Joiner.on(" ")
          .skipNulls()
          .join(
              new String[] {
                "DELETE",
                "FROM",
                ANY_KEYSPACE_NAME + "." + ANY_TABLE_NAME,
                "WHERE",
                ANY_NAME_1 + "=?",
                "AND",
                ANY_NAME_2 + "=?",
                "IF",
                ANY_NAME_3 + "=?",
                "AND",
                ANY_NAME_4 + "=?;"
              });
  configureBehavior(expected);
  del = prepareDeleteWithClusteringKey();
  del.withCondition(
      new DeleteIf(
          new ConditionalExpression(ANY_NAME_3, new IntValue(ANY_INT_1), Operator.EQ),
          new ConditionalExpression(ANY_NAME_4, new TextValue(ANY_TEXT_3), Operator.EQ)));

  // Act
  handler.prepare(del);

  // Assert
  verify(session).prepare(expected);
}
 

private void assertReadMetricValuesForSelectSql(ArrayList<Long> numRows, ArrayList<Long> numExpectedTasks,
        PhoenixResultSet resultSetBeingTested, Set<String> expectedTableNames) throws SQLException {
    Map<String, Map<MetricType, Long>> metrics = PhoenixRuntime.getRequestReadMetricInfo(resultSetBeingTested);
    int counter = 0;
    for (Entry<String, Map<MetricType, Long>> entry : metrics.entrySet()) {
        String tableName = entry.getKey();
        expectedTableNames.remove(tableName);
        Map<MetricType, Long> metricValues = entry.getValue();
        boolean taskCounterMetricsPresent = false;
        boolean taskExecutionTimeMetricsPresent = false;
        boolean memoryMetricsPresent = false;
        for (Entry<MetricType, Long> pair : metricValues.entrySet()) {
        	MetricType metricType = pair.getKey();
            long metricValue = pair.getValue();
            long numTask = numExpectedTasks.get(counter);
            if (metricType.equals(TASK_EXECUTED_COUNTER)) {
                assertEquals(numTask, metricValue);
                taskCounterMetricsPresent = true;
            } else if (metricType.equals(TASK_EXECUTION_TIME)) {
                assertEquals(numTask * TASK_EXECUTION_TIME_DELTA, metricValue);
                taskExecutionTimeMetricsPresent = true;
            } else if (metricType.equals(MEMORY_CHUNK_BYTES)) {
                assertEquals(numTask * MEMORY_CHUNK_BYTES_DELTA, metricValue);
                memoryMetricsPresent = true;
            }
        }
        counter++;
        assertTrue(taskCounterMetricsPresent);
        assertTrue(taskExecutionTimeMetricsPresent);
        assertTrue(memoryMetricsPresent);
    }
    PhoenixRuntime.resetMetrics(resultSetBeingTested);
    assertTrue("Metrics not found tables " + Joiner.on(",").join(expectedTableNames),
            expectedTableNames.size() == 0);
}
 

@Override
public Void visitSetPath(SetPath node, Integer indent)
{
    builder.append("SET PATH ");
    builder.append(Joiner.on(", ").join(node.getPathSpecification().getPath()));
    return null;
}
 

/**
 * Remove volumes from DataNode.
 *
 * It does three things:
 * <li>
 *   <ul>Remove volumes and block info from FsDataset.</ul>
 *   <ul>Remove volumes from DataStorage.</ul>
 *   <ul>Reset configuration DATA_DIR and {@link dataDirs} to represent
 *   active volumes.</ul>
 * </li>
 * @param absoluteVolumePaths the absolute path of volumes.
 * @param clearFailure if true, clears the failure information related to the
 *                     volumes.
 * @throws IOException
 */
private synchronized void removeVolumes(
    final Set<File> absoluteVolumePaths, boolean clearFailure)
    throws IOException {
  for (File vol : absoluteVolumePaths) {
    Preconditions.checkArgument(vol.isAbsolute());
  }

  if (absoluteVolumePaths.isEmpty()) {
    return;
  }

  LOG.info(String.format("Deactivating volumes (clear failure=%b): %s",
      clearFailure, Joiner.on(",").join(absoluteVolumePaths)));

  IOException ioe = null;
  // Remove volumes and block infos from FsDataset.
  data.removeVolumes(absoluteVolumePaths, clearFailure);

  // Remove volumes from DataStorage.
  try {
    storage.removeVolumes(absoluteVolumePaths);
  } catch (IOException e) {
    ioe = e;
  }

  // Set configuration and dataDirs to reflect volume changes.
  for (Iterator<StorageLocation> it = dataDirs.iterator(); it.hasNext(); ) {
    StorageLocation loc = it.next();
    if (absoluteVolumePaths.contains(loc.getFile().getAbsoluteFile())) {
      it.remove();
    }
  }
  conf.set(DFS_DATANODE_DATA_DIR_KEY, Joiner.on(",").join(dataDirs));

  if (ioe != null) {
    throw ioe;
  }
}
 

/** Change the boot classpath.
 * This option is only supported on JDK 8 and older and will be ignored when source level is 9 or newer.
 *
 * @param bootClasspath the new boot classpath.
 * @see "https://www.oracle.com/technetwork/java/javase/9-relnote-issues-3704069.html"
 */
public void setBootClassPath(Collection<File> bootClasspath) {
	final JavaVersion version = JavaVersion.fromQualifier(getJavaSourceVersion());
	if (version.isAtLeast(JavaVersion.JAVA9)) {
		reportInternalWarning(MessageFormat.format(Messages.SarlBatchCompiler_63,
				Joiner.on(File.pathSeparator).join(bootClasspath)));
	}
	if (bootClasspath == null || bootClasspath.isEmpty()) {
		this.bootClasspath = null;
	} else {
		this.bootClasspath = new ArrayList<>(bootClasspath);
	}
}
 

@Override
public String toString() {
  return getFunction().getName()
      + "("
      + Joiner.on(", ").join(Iterables.transform(getArgs(), Object::toString))
      + ")";
}
 

protected void preview() {
	if (this.editor != null) {
		if (!validateRegexp()) {
			return;
		}
		List<String> result = sort(editor, getSettings());

		ApplicationManager.getApplication().runWriteAction(() -> {
			myPreviewEditor.getDocument().setText(Joiner.on("\n").join(result));
			myPreviewPanel.validate();
			myPreviewPanel.repaint();
		});
	}
}
 

public MqPullService(final String server, final int index) {
    this.mqPullServiceName = Joiner.on("-").join("mqPullServiceName", index);

    CarreraConfig carreraConfig = new CarreraConfig();
    carreraConfig.setServers(server);
    carreraConfig.setGroupId(PULL_CONFIG.getInnerGroup());
    carreraConfig.setRetryInterval(PULL_CONFIG.getRetryIntervalMs());
    carreraConfig.setTimeout(PULL_CONFIG.getTimeoutMs());
    carreraConfig.setMaxBatchSize(PULL_CONFIG.getMaxBatchSize());

    carreraConsumer = new SimpleCarreraConsumer(carreraConfig);
    LOGGER.info("{} init carrera consumer, carreraConfig:{}", mqPullServiceName, carreraConfig);
}
 

@Test
public void testGetAnnotationAndGetFieldWithSingleClass() throws Exception {
  testCompiler.addClasspathFileContents(
      "AnnotationWithSingleClassForTreeBackedTest.java",
      AnnotationWithSingleClassForTreeBackedTest.SOURCE_CODE);

  if (!testingTrees()) {
    testCompiler.addClasspathFileContents("Bar.java", "public class Bar {}");
  }

  initCompiler(
      ImmutableMap.of(
          "Foo.java",
          Joiner.on('\n')
              .join(
                  "@com.facebook.buck.jvm.java.abi.source.AnnotationWithSingleClassForTreeBackedTest(single = Bar.class)",
                  "public class Foo {",
                  "}")));
  testCompiler.setProcessors(
      Collections.singletonList(
          new ProcessorCallingGetAnnotation<>(
              AnnotationWithSingleClassForTreeBackedTest.class,
              (a) -> {
                try {
                  a.single();
                } catch (MirroredTypeException e) { // NOPMD: Expected.
                  // NOPMD: No problem.
                }
              })));

  testCompiler.parse();
  testCompiler.enter();
}
 

void modifyFile(String fileName, String... content) throws IOException {
  Path path = workspace.getRelative(fileName);
  Preconditions.checkState(path.exists());
  Preconditions.checkState(path.delete());
  FileSystemUtils.writeContentAsLatin1(path, Joiner.on('\n').join(content));
  changes.add(path);
}
 

@Override
protected void init() {
  checkArgument(
      ReservedList.get(name).isPresent(),
      "Cannot delete the reserved list %s because it doesn't exist.",
      name);
  ReservedList existing = ReservedList.get(name).get();
  ImmutableSet<String> tldsUsedOn = existing.getReferencingTlds();
  checkArgument(
      tldsUsedOn.isEmpty(),
      "Cannot delete reserved list because it is used on these tld(s): %s",
      Joiner.on(", ").join(tldsUsedOn));
  stageEntityChange(existing, null);
}
 

protected Map<String, String> userWithGroups() {
    Map<String, String> temp = Maps.newHashMap();
    Map<String, List<String>> userGroups = userService.userWithAssignmentGroupStr();
    for (String user : userGroups.keySet()) {
        List<String> groupIds = userGroups.get(user);
        temp.put(user, Joiner.on(", ").join(groupIds));
    }
    return temp;
}