org.apache.logging.log4j.util.Strings Java Examples

private void handle(GetKVMHostDownloadCredentialMsg msg) {
    final GetKVMHostDownloadCredentialReply reply = new GetKVMHostDownloadCredentialReply();

    String key = asf.getPrivateKey();

    String hostname = null;
    if (Strings.isNotEmpty(msg.getDataNetworkCidr())) {
        String dataNetworkAddress = getDataNetworkAddress(self.getUuid(), msg.getDataNetworkCidr());

        if (dataNetworkAddress != null) {
            hostname = dataNetworkAddress;
        }
    }

    reply.setHostname(hostname == null ? getSelf().getManagementIp() : hostname);
    reply.setUsername(getSelf().getUsername());
    reply.setSshPort(getSelf().getPort());
    reply.setSshKey(key);
    bus.reply(msg, reply);
}
 

private synchronized void processFrames() throws IOException {
    try {
        int count = 0;
        while (!shutdown) {
            String message = Strings.EMPTY;
            message = syslogReader.read();
            messageList.add(message);
            count++;
            if (isEndOfMessages(count)) {
                break;
            }
        }
        this.notify();
    }
    catch(final Exception e) {
        this.notify();
        throw new IOException(e);
    }
}
 

@NotNull
public static ImmutableGermlineVariant.Builder createTestGermlineVariantBuilder() {
    return ImmutableGermlineVariant.builder()
            .passFilter(true)
            .gene(Strings.EMPTY)
            .ref(Strings.EMPTY)
            .alt(Strings.EMPTY)
            .codingEffect(CodingEffect.UNDEFINED)
            .chromosome(Strings.EMPTY)
            .position(0)
            .hgvsCodingImpact(Strings.EMPTY)
            .hgvsProteinImpact(Strings.EMPTY)
            .totalReadCount(0)
            .alleleReadCount(0)
            .adjustedCopyNumber(0)
            .adjustedVAF(0)
            .biallelic(false);
}
 

@NotNull
public static ImmutableReportableVariant.Builder createTestReportableVariantBuilder() {
    return ImmutableReportableVariant.builder()
            .gene(Strings.EMPTY)
            .position(0)
            .chromosome(Strings.EMPTY)
            .ref(Strings.EMPTY)
            .alt(Strings.EMPTY)
            .canonicalCodingEffect(CodingEffect.UNDEFINED)
            .canonicalHgvsCodingImpact(Strings.EMPTY)
            .canonicalHgvsProteinImpact(Strings.EMPTY)
            .gDNA(Strings.EMPTY)
            .hotspot(Hotspot.HOTSPOT)
            .clonalLikelihood(1D)
            .alleleReadCount(0)
            .totalReadCount(0)
            .allelePloidy(0D)
            .totalPloidy(0)
            .biallelic(false)
            .driverCategory(DriverCategory.ONCO)
            .driverLikelihood(0D)
            .notifyClinicalGeneticist(false);
}
 

public PKCS10CertificationRequest build() throws SCMSecurityException {
  Preconditions.checkNotNull(key, "KeyPair cannot be null");
  Preconditions.checkArgument(Strings.isNotBlank(subject), "Subject " +
      "cannot be blank");

  try {
    CertificateSignRequest csr = new CertificateSignRequest(subject, scmID,
        clusterID, key, config, createExtensions());
    return csr.generateCSR();
  } catch (IOException ioe) {
    throw new CertificateException(String.format("Unable to create " +
        "extension for certificate sign request for %s.", SecurityUtil
        .getDistinguishedName(subject, scmID, clusterID)), ioe.getCause());
  } catch (OperatorCreationException ex) {
    throw new CertificateException(String.format("Unable to create " +
        "certificate sign request for %s.", SecurityUtil
        .getDistinguishedName(subject, scmID, clusterID)),
        ex.getCause());
  }
}
 

private void setFields(final MapMessage<?, ?> mapMessage) throws SQLException {
    final IndexedReadOnlyStringMap map = mapMessage.getIndexedReadOnlyStringMap();
    final String simpleName = statement.getClass().getName();
    int j = 1; // JDBC indices start at 1
    for (final ColumnMapping mapping : this.factoryData.columnMappings) {
        if (mapping.getLiteralValue() == null) {
            final String source = mapping.getSource();
            final String key = Strings.isEmpty(source) ? mapping.getName() : source;
            final Object value = map.getValue(key);
            if (logger().isTraceEnabled()) {
                final String valueStr = value instanceof String ? "\"" + value + "\""
                        : Objects.toString(value, null);
                logger().trace("{} setObject({}, {}) for key '{}' and mapping '{}'", simpleName, j, valueStr, key,
                        mapping.getName());
            }
            setStatementObject(j, mapping.getNameKey(), value);
            j++;
        }
    }
}
 

/**
 * Factory method for creating a connection source within the plugin manager.
 *
 * @param jndiName The full JNDI path where the data source is bound. Should start with java:/comp/env or
 *                 environment-equivalent.
 * @return the created connection source.
 */
@PluginFactory
public static DataSourceConnectionSource createConnectionSource(@PluginAttribute final String jndiName) {
    if (Strings.isEmpty(jndiName)) {
        LOGGER.error("No JNDI name provided.");
        return null;
    }

    try {
        final InitialContext context = new InitialContext();
        final DataSource dataSource = (DataSource) context.lookup(jndiName);
        if (dataSource == null) {
            LOGGER.error("No data source found with JNDI name [" + jndiName + "].");
            return null;
        }

        return new DataSourceConnectionSource(jndiName, dataSource);
    } catch (final NamingException e) {
        LOGGER.error(e.getMessage(), e);
        return null;
    }
}
 

@NotNull
public static DriverCatalog createTestDriverCatalogEntry(@NotNull String gene) {
    return ImmutableDriverCatalog.builder()
            .gene(gene)
            .chromosome(Strings.EMPTY)
            .chromosomeBand(Strings.EMPTY)
            .category(DriverCategory.ONCO)
            .driver(DriverType.MUTATION)
            .likelihoodMethod(LikelihoodMethod.NONE)
            .driverLikelihood(0D)
            .dndsLikelihood(0D)
            .missense(0)
            .nonsense(0)
            .splice(0)
            .inframe(0)
            .frameshift(0)
            .biallelic(false)
            .minCopyNumber(0)
            .maxCopyNumber(0)
            .build();
}
 

@Override
public BackendEntry writeIndex(HugeIndex index) {
    TableBackendEntry entry = newBackendEntry(index);
    /*
     * When field-values is null and elementIds size is 0, it is
     * meaningful for deletion of index data in secondary/range index.
     */
    if (index.fieldValues() == null && index.elementIds().size() == 0) {
        entry.column(HugeKeys.INDEX_LABEL_ID, index.indexLabel().longId());
    } else {
        Object value = index.fieldValues();
        if (value != null && "\u0000".equals(value)) {
            value = Strings.EMPTY;
        }
        entry.column(HugeKeys.FIELD_VALUES, value);
        entry.column(HugeKeys.INDEX_LABEL_ID, index.indexLabel().longId());
        entry.column(HugeKeys.ELEMENT_IDS,
                     IdUtil.writeStoredString(index.elementId()));
        entry.column(HugeKeys.EXPIRED_TIME, index.expiredTime());
        entry.subId(index.elementId());
    }
    return entry;
}
 

@NotNull
private static SampleReport createSkinMelanomaSampleReport(@NotNull String sample) {
    SampleMetadata sampleMetadata = ImmutableSampleMetadata.builder()
            .refSampleId(Strings.EMPTY)
            .refSampleBarcode("FR12123488")
            .tumorSampleId(sample)
            .tumorSampleBarcode("FR12345678")
            .build();

    return ImmutableSampleReport.builder()
            .sampleMetadata(sampleMetadata)
            .patientTumorLocation(ImmutablePatientTumorLocation.of(Strings.EMPTY, "Skin", "Melanoma"))
            .refArrivalDate(LocalDate.parse("01-Jan-2020", DATE_FORMATTER))
            .tumorArrivalDate(LocalDate.parse("05-Jan-2020", DATE_FORMATTER))
            .shallowSeqPurityString(Lims.NOT_PERFORMED_STRING)
            .labProcedures("PREP013V23-QC037V20-SEQ008V25")
            .cohort("TEST")
            .projectName("TEST-001-002")
            .submissionId("SUBM")
            .hospitalContactData(createTestHospitalContactData())
            .hospitalPatientId("HOSP1")
            .hospitalPathologySampleId("PA1")
            .build();
}
 

@Test
public void testPatternColumn03() {
    final ColumnConfig config = ColumnConfig.newBuilder()
        .setName("col3")
        .setPattern("%X{id} %level")
        .setLiteral(Strings.EMPTY)
        .setEventTimestamp(false)
        .setUnicode(true)
        .setClob(false)
        .build();

    assertNotNull("The result should not be null.", config);
    assertEquals("The column name is not correct.", "col3", config.getColumnName());
    assertNotNull("The pattern should not be null.", config.getLayout());
    assertEquals("The pattern is not correct.", "%X{id} %level", config.getLayout().toString());
    assertNull("The literal value should be null.", config.getLiteralValue());
    assertFalse("The timestamp flag should be false.", config.isEventTimestamp());
    assertTrue("The unicode flag should be true.", config.isUnicode());
    assertFalse("The clob flag should be false.", config.isClob());
}
 

private void renderMicrosatelliteStabilityCharacteristic(@NotNull Document reportDocument) {
    boolean hasReliablePurity = patientReport.hasReliablePurity();
    double microSatelliteStability = patientReport.microsatelliteIndelsPerMb();
    String microSatelliteStabilityString = hasReliablePurity ? patientReport.microsatelliteStatus().display() + " "
            + DOUBLE_DECIMAL_FORMAT.format(patientReport.microsatelliteIndelsPerMb()) : DataUtil.NA_STRING;

    BarChart satelliteChart =
            new BarChart(microSatelliteStability, MicroSatelliteStatus.RANGE_MIN, MicroSatelliteStatus.RANGE_MAX, "MSS", "MSI", false);
    satelliteChart.enabled(hasReliablePurity);
    satelliteChart.scale(InlineBarChart.LOG10_SCALE);
    satelliteChart.setTickMarks(new double[] { MicroSatelliteStatus.RANGE_MIN, 10, MicroSatelliteStatus.RANGE_MAX },
            DOUBLE_DECIMAL_FORMAT);
    satelliteChart.enableUndershoot(NO_DECIMAL_FORMAT.format(0));
    satelliteChart.enableOvershoot(">" + NO_DECIMAL_FORMAT.format(satelliteChart.max()));
    satelliteChart.setIndicator(MicroSatelliteStatus.THRESHOLD,
            "Microsatellite \ninstability (" + DOUBLE_DECIMAL_FORMAT.format(MicroSatelliteStatus.THRESHOLD) + ")");
    reportDocument.add(createCharacteristicDiv("Microsatellite status",
            microSatelliteStabilityString,
            "The microsatellite stability score represents the number of somatic inserts and deletes in "
                    + "(short) repeat sections across the whole genome of the tumor per Mb. This metric can be "
                    + "considered as a good marker for instability in microsatellite repeat regions. Tumors with a "
                    + "score greater than 4.0 are considered microsatellite unstable (MSI).",
            satelliteChart,
            Strings.EMPTY,
            false));
}
 

@Test
public void testJavaScriptPatternSelector() throws Exception {
    final org.apache.logging.log4j.Logger logger = LogManager.getLogger("TestJavaScriptPatternSelector");
    final org.apache.logging.log4j.Logger logger2 = LogManager.getLogger("JavascriptNoLocation");
    logger.traceEntry();
    logger.info("Hello World");
    logger2.info("No location information");
    logger.traceExit();
    final ListAppender app = (ListAppender) context.getRequiredAppender("List3");
    assertNotNull("No ListAppender", app);
    final List<String> messages = app.getMessages();
    assertNotNull("No Messages", messages);
    assertTrue("Incorrect number of messages. Expected 4, Actual " + messages.size() + ": " + messages, messages.size() == 4);
    String expect = "[TRACE] TestJavaScriptPatternSelector ====== " +
            "o.a.l.l.c.PatternSelectorTest.testJavaScriptPatternSelector:85 Enter ======" + Strings.LINE_SEPARATOR;
    assertEquals(expect, messages.get(0));
    expect = "[INFO ] TestJavaScriptPatternSelector " +
            "o.a.l.l.c.PatternSelectorTest.testJavaScriptPatternSelector.86 Hello World" + Strings.LINE_SEPARATOR;
    assertEquals(expect, messages.get(1));
    assertEquals("[INFO ] JavascriptNoLocation No location information" + Strings.LINE_SEPARATOR, messages.get(2));
    app.clear();
}
 

@Test
public void testMarkerPatternSelector() throws Exception {
    final org.apache.logging.log4j.Logger logger = LogManager.getLogger("TestMarkerPatternSelector");
    logger.traceEntry();
    logger.info("Hello World");
    logger.traceExit();
    final ListAppender app = (ListAppender) context.getRequiredAppender("List");
    assertNotNull("No ListAppender", app);
    final List<String> messages = app.getMessages();
    assertNotNull("No Messages", messages);
    assertTrue("Incorrect number of messages. Expected 3, Actual " + messages.size() + ": " + messages, messages.size() == 3);
    final String expect = String.format("[TRACE] TestMarkerPatternSelector ====== "
            + "o.a.l.l.c.PatternSelectorTest.testMarkerPatternSelector:43 Enter ======%n");
    assertEquals(expect, messages.get(0));
    assertEquals("[INFO ] TestMarkerPatternSelector Hello World" + Strings.LINE_SEPARATOR, messages.get(1));
    app.clear();
}
 

@NotNull
static ModifiableVariantHotspotEvidence create(@NotNull final VariantHotspot hotspot) {
    return ModifiableVariantHotspotEvidence.create()
            .from(hotspot)
            .setRef(hotspot.ref())
            .setAlt(hotspot.alt())
            .setAltQuality(0)
            .setAltSupport(0)
            .setRefSupport(0)
            .setRefQuality(0)
            .setIndelSupport(0)
            .setReadDepth(0)
            .setAltMapQuality(0)
            .setAltMinQuality(0)
            .setAltDistanceFromRecordStart(0)
            .setAltMinDistanceFromAlignment(0)
            .setSubprimeReadDepth(0)
            .setReadContext(Strings.EMPTY)
            .setReadContextCount(0)
            .setReadContextCountOther(0);
}
 

@Test
public void testLog() {
    final Log logger = LogFactory.getLog("LoggerTest");
    logger.debug("Test message");
    verify("List", "o.a.l.l.j.LoggerTest Test message MDC{}" + Strings.LINE_SEPARATOR);
    logger.debug("Exception: " , new NullPointerException("Test"));
    verify("List", "o.a.l.l.j.LoggerTest Exception:  MDC{}" + Strings.LINE_SEPARATOR);
    logger.info("Info Message");
    verify("List", "o.a.l.l.j.LoggerTest Info Message MDC{}" + Strings.LINE_SEPARATOR);
    logger.info("Info Message {}");
    verify("List", "o.a.l.l.j.LoggerTest Info Message {} MDC{}" + Strings.LINE_SEPARATOR);
}
 

@Override
public Level convertToEntityAttribute(final String s) {
    if (Strings.isEmpty(s)) {
        return null;
    }

    return Level.toLevel(s, null);
}
 

private Pod getCurrentPod(KubernetesClient kubernetesClient) {
    String hostName = System.getenv(HOSTNAME);
    try {
        if (isServiceAccount() && Strings.isNotBlank(hostName)) {
            return kubernetesClient.pods().withName(hostName).get();
        }
    } catch (Throwable t) {
        LOGGER.debug("Unable to locate pod with name {}.", hostName);
    }
    return null;
}
 

@Test
public void simpleFlow() {
    xlogger.entry(CONFIG);
    verify("List", "o.a.l.s.LoggerTest entry with (log4j-test1.xml) MDC{}" + Strings.LINE_SEPARATOR);
    xlogger.exit(0);
    verify("List", "o.a.l.s.LoggerTest exit with (0) MDC{}" + Strings.LINE_SEPARATOR);
}
 

@NotNull
private static List<ClinicalTrial> createCOLO829ClinicalTrials() {
    List<ClinicalTrial> trials = Lists.newArrayList();
    ImmutableClinicalTrial.Builder iclusionBuilder =
            ImmutableClinicalTrial.builder().cancerType(Strings.EMPTY).isOnLabel(true).source(ActionabilitySource.ICLUSION);

    trials.add(iclusionBuilder.event("BRAF p.Val600Glu")
            .scope(EvidenceScope.GENE_LEVEL)
            .acronym("CLXH254X2101")
            .reference("EXT10453 (NL55506.078.15)")
            .build());
    trials.add(iclusionBuilder.event("BRAF p.Val600Glu")
            .scope(EvidenceScope.SPECIFIC)
            .acronym("COWBOY")
            .reference("EXT12301 (NL71732.091.19)")
            .build());
    trials.add(iclusionBuilder.event("BRAF p.Val600Glu")
            .scope(EvidenceScope.GENE_LEVEL)
            .acronym("DRUP")
            .reference("EXT10299 (NL54757.031.16)")
            .build());
    trials.add(iclusionBuilder.event("BRAF p.Val600Glu")
            .scope(EvidenceScope.GENE_LEVEL)
            .acronym("EBIN (EORTC-1612-MG)")
            .reference("EXT11284 (NL67202.031.18)")
            .build());
    trials.add(iclusionBuilder.event("BRAF p.Val600Glu")
            .scope(EvidenceScope.GENE_LEVEL)
            .acronym("POLARIS")
            .reference("EXT11388 (NL69569.028.19)")
            .build());
    trials.add(iclusionBuilder.event("CDKN2A p.Ala68fs")
            .scope(EvidenceScope.GENE_LEVEL)
            .acronym("DRUP")
            .reference("EXT10299 (NL54757.031.16)")
            .build());

    return trials;
}
 

/**
 * Default constructor.
 */
public LoggerConfig() {
    this.logEventFactory = LOG_EVENT_FACTORY;
    this.level = Level.ERROR;
    this.name = Strings.EMPTY;
    this.properties = null;
    this.propertiesRequireLookup = false;
    this.config = null;
    this.reliabilityStrategy = new DefaultReliabilityStrategy(this);
}
 

@NotNull
public static KnownFusions checkFusionPromiscuous(@NotNull ViccEntry viccEntry, @NotNull String gene, @NotNull String event) {
    String function =
            viccEntry.association().evidence().description() == null ? Strings.EMPTY : viccEntry.association().evidence().description();

    if (FUSIONS_PROMISCUOUS.contains(event)) {
        GenomicEvents typeEvent = GenomicEvents.genomicEvents("fusion promiscuous");
        return FusionExtractor.determinePromiscuousFusions(viccEntry.source(), typeEvent.toString(), gene, function);
    }
    return ImmutableKnownFusions.builder().gene("").eventType("").source("").sourceLink("").build();
}
 

private void addMetadataToProperties(final List<BaleenDocumentMetadata> list, final JCas jCas) {
  for (final Metadata metadata : JCasUtil.select(jCas, Metadata.class)) {
    String key = metadata.getKey();
    if (key.contains(".")) {
      // Field names can't contain a "." in Mongo, so replace with a _
      key = key.replaceAll("\\.", "_");
    }

    final String value = metadata.getValue();
    if (!Strings.isEmpty(key) && !Strings.isEmpty(value)) {
      list.add(new BaleenDocumentMetadata(key, value));
    }
  }
}
 

/**
 * Adds a list of package names to be scanned for plugins. Convenience method for {@link #addPackage(String)}.
 *
 * @param packages collection of package names to add. Empty and null package names are ignored.
 */
public static void addPackages(final Collection<String> packages) {
    for (final String pkg : packages) {
        if (Strings.isNotBlank(pkg)) {
            PACKAGES.addIfAbsent(pkg);
        }
    }
}
 

@Test
public void mdc() {

    MDC.put("TestYear", "2010");
    logger.debug("Debug message");
    verify("List", "o.a.l.s.LoggerTest Debug message MDC{TestYear=2010}" + Strings.LINE_SEPARATOR);
    MDC.clear();
    logger.debug("Debug message");
    verify("List", "o.a.l.s.LoggerTest Debug message MDC{}" + Strings.LINE_SEPARATOR);
}
 

/**
 * Factory method to create a LoggerConfig.
 *
 * @param additivity True if additive, false otherwise.
 * @param level The Level to be associated with the Logger.
 * @param loggerName The name of the Logger.
 * @param includeLocation "true" if location should be passed downstream
 * @param refs An array of Appender names.
 * @param properties Properties to pass to the Logger.
 * @param config The Configuration.
 * @param filter A Filter.
 * @return A new LoggerConfig.
 * @since 3.0
 */
@PluginFactory
public static LoggerConfig createLogger(
        @PluginAttribute(defaultBoolean = true) final boolean additivity,
        @PluginAttribute final Level level,
        @Required(message = "Loggers cannot be configured without a name") @PluginAttribute("name") final String loggerName,
        @PluginAttribute final String includeLocation,
        @PluginElement final AppenderRef[] refs,
        @PluginElement final Property[] properties,
        @PluginConfiguration final Configuration config,
        @PluginElement final Filter filter) {
    final String name = loggerName.equals(ROOT) ? Strings.EMPTY : loggerName;
    return new AsyncLoggerConfig(name, Arrays.asList(refs), filter, level, additivity, properties, config,
            includeLocation(includeLocation));
}
 

@NotNull
public static ImmutableStructuralVariantImpl.Builder createStructuralVariantSingleBreakend(@NotNull final String startChromosome,
       final long startPosition, double startVaf) {
    return ImmutableStructuralVariantImpl.builder()
            .id(Strings.EMPTY)
            .insertSequence(Strings.EMPTY)
            .insertSequenceAlignments(Strings.EMPTY)
            .qualityScore(0)
            .recovered(false)
            .type(StructuralVariantType.BND)
            .start(createStartLeg(startChromosome, startPosition, StructuralVariantType.BND).alleleFrequency(startVaf).build())
            .startContext(dummyContext())
            .imprecise(false);
}
 

@Test
public void debugNoParms() {
    logger.debug("Debug message {}");
    verify("List", "o.a.l.s.LoggerTest Debug message {} MDC{}" + Strings.LINE_SEPARATOR);
    logger.debug("Debug message {}", (Object[]) null);
    verify("List", "o.a.l.s.LoggerTest Debug message {} MDC{}" + Strings.LINE_SEPARATOR);
    ((LocationAwareLogger)logger).log(null, Log4jLogger.class.getName(), LocationAwareLogger.DEBUG_INT,
        "Debug message {}", null, null);
    verify("List", "o.a.l.s.LoggerTest Debug message {} MDC{}" + Strings.LINE_SEPARATOR);
}
 

private List<String> getGuidFromMapList(List value) {
    List<String> guids;
    guids = (List<String>) value.stream().map(e -> {
        if (e instanceof Map) {
            return (String) ((Map) e).get("guid");
        } else {
            return Strings.EMPTY;
        }
    }).collect(Collectors.toList());
    return guids;
}
 

private StatusLogger(final String name, final MessageFactory messageFactory) {
    super(name, messageFactory);
    final String dateFormat = PROPS.getStringProperty(STATUS_DATE_FORMAT, Strings.EMPTY);
    final boolean showDateTime = !Strings.isEmpty(dateFormat);
    this.logger = new SimpleLogger("StatusLogger", Level.ERROR, false, true, showDateTime, false,
            dateFormat, messageFactory, PROPS, System.err);
    this.listenersLevel = Level.toLevel(DEFAULT_STATUS_LEVEL, Level.WARN).intLevel();

    // LOG4J2-1813 if system property "log4j2.debug" is defined, print all status logging
    if (isDebugPropertyEnabled()) {
        logger.setLevel(Level.TRACE);
    }
}