How to use

BatfishLogger

in

org.batfish.common

private void serializeAwsConfigs(
  Path testRigPath, Path outputPath, ParseVendorConfigurationAnswerElement pvcae) {
 Map<Path, String> configurationData =
   readConfigurationFiles(testRigPath, BfConsts.RELPATH_AWS_CONFIGS_DIR);
 AwsConfiguration config;
 try (ActiveSpan parseAwsConfigsSpan =
   GlobalTracer.get().buildSpan("Parse AWS configs").startActive()) {
  assert parseAwsConfigsSpan != null; // avoid unused warning
  config = parseAwsConfigurations(configurationData, pvcae);
 }
 _logger.info("\n*** SERIALIZING AWS CONFIGURATION STRUCTURES ***\n");
 _logger.resetTimer();
 outputPath.toFile().mkdirs();
 Path currentOutputPath = outputPath.resolve(BfConsts.RELPATH_AWS_CONFIGS_FILE);
 _logger.debugf("Serializing AWS to \"%s\"...", currentOutputPath);
 serializeObject(config, currentOutputPath);
 _logger.debug("OK\n");
 _logger.printElapsedTime();
}

boolean delNetwork(String networkName) {
 try {
  WebTarget webTarget =
    getTargetV2(Lists.newArrayList(CoordConstsV2.RSC_NETWORKS, networkName));
  Response response =
    webTarget
      .request(MediaType.APPLICATION_JSON)
      .header(CoordConstsV2.HTTP_HEADER_BATFISH_APIKEY, _settings.getApiKey())
      .header(CoordConstsV2.HTTP_HEADER_BATFISH_VERSION, Version.getVersion())
      .delete();
  if (response.getStatus() != Status.NO_CONTENT.getStatusCode()) {
   _logger.errorf("delNetwork: Did not get OK response. Got: %s\n", response.getStatus());
   _logger.error(response.readEntity(String.class) + "\n");
   return false;
  }
  return true;
 } catch (Exception e) {
  _logger.errorf("Exception in delNetwork from %s for %s\n", _coordWorkMgrV2, networkName);
  _logger.error(Throwables.getStackTraceAsString(e) + "\n");
  return false;
 }
}

private SortedMap<Path, String> readConfigurationFiles(Path testRigPath, String configsType) {
 _logger.infof("\n*** READING %s FILES ***\n", configsType);
 _logger.resetTimer();
 SortedMap<Path, String> configurationData = new TreeMap<>();
 Path configsPath = testRigPath.resolve(configsType);
 List<Path> configFilePaths = listAllFiles(configsPath);
 AtomicInteger completed =
   newBatch("Reading network configuration files", configFilePaths.size());
 for (Path file : configFilePaths) {
  _logger.debugf("Reading: \"%s\"\n", file);
  String fileTextRaw = CommonUtil.readFile(file.toAbsolutePath());
  String fileText = fileTextRaw + ((fileTextRaw.length() != 0) ? "\n" : "");
  configurationData.put(file, fileText);
  completed.incrementAndGet();
 }
 _logger.printElapsedTime();
 return configurationData;
}

public void printElapsedTime() {
 double seconds = getElapsedTime(_timerCount);
 info("Time taken for this task: " + seconds + " seconds\n");
}

public Set<Flow> computeCompositeNodOutput(
  List<CompositeNodJob> jobs, NodAnswerElement answerElement) {
 _logger.info("\n*** EXECUTING COMPOSITE NOD JOBS ***\n");
 _logger.resetTimer();
 Set<Flow> flows = new TreeSet<>();
 BatfishJobExecutor.runJobsInExecutor(
   _settings, _logger, jobs, flows, answerElement, true, "Composite NOD");
 _logger.printElapsedTime();
 return flows;
}

private boolean showLogLevel(List<String> options, List<String> parameters) {
 if (!isValidArgument(options, parameters, 0, 0, 0, Command.SHOW_LOGLEVEL)) {
  return false;
 }
 _logger.outputf("Current client log level is %s\n", _logger.getLogLevelStr());
 return true;
}

    .post(Entity.entity(multiPart, multiPart.getMediaType()));
_logger.debug(response.getStatus() + " " + response.getStatusInfo() + " " + response + "\n");
 _logger.debugf(
   "GetObject: Did not get an OK response for %s -> %s->%s\n",
   networkName, snapshotName, objectName);
_logger.errorf(
  "Exception in getObject from %s using (%s, %s)\n",
  _coordWorkMgr, snapshotName, objectName);
_logger.error(Throwables.getStackTraceAsString(e) + "\n");
return null;

 public BatfishJob(Settings settings) {
  _settings = settings;
  _logger = new BatfishLogger(_settings.getLogLevel(), _settings.getTimestamp());
 }
}

  _workHelper.getObject(wItem.getContainerName(), wItem.getTestrigName(), ansFileName);
if (downloadedAnsFile == null) {
 _logger.errorf("Failed to get answer file %s. (Was work killed?)\n", ansFileName);
} else {
 String answerString = CommonUtil.readFile(Paths.get(downloadedAnsFile));
   answerStringToPrint = answer.prettyPrint();
  } catch (IOException e) {
   _logger.warnf(
     "Using Json for pretty printing because could not deserialize response as %s: %s",
     Answer.class.getSimpleName(), e.getMessage());
 if (_logger.getLogLevel() >= BatfishLogger.LEVEL_DEBUG) {
  try {
   ObjectMapper reader = BatfishObjectMapper.mapper();
    _logger.errorf(
      "Original and recovered Json are different. Recovered = %s\n", newAnswerString);
   _logger.outputf("Could NOT deserialize Json to Answer: %s\n", e.getMessage());
if (_logger.getLogLevel() >= BatfishLogger.LEVEL_DEBUG) {
 _logger.output("---------------- Service Log --------------\n");
 String logFileName = wItem.getId() + BfConsts.SUFFIX_LOG_FILE;
 String downloadedFileStr =
  _logger.errorf("Failed to get log file %s\n", logFileName);
  return false;
 } else {

String baseUrl = String.format("%s://%s", protocol, _mainSettings.getServiceBindHost());
URI baseUri = UriBuilder.fromUri(baseUrl).port(_mainSettings.getServicePort()).build();
_mainLogger.debug(String.format("Starting server at %s\n", baseUri));
ResourceConfig rc = new ResourceConfig(Service.class).register(new JettisonFeature());
if (_mainSettings.getTracingEnable()) {
   _mainLogger.errorf(
     "Parent process monitoring is not supported on Windows. We'll live without it.");
  } else {
       PARENT_CHECK_INTERVAL_MS,
       TimeUnit.MILLISECONDS);
   SignalHandler handler = signal -> _mainLogger.infof("BFS: Ignoring signal %s\n", signal);
   Signal.handle(new Signal("INT"), handler);
 _mainLogger.error(msg);
 System.exit(1);
} catch (Exception ex) {
 String stackTrace = Throwables.getStackTraceAsString(ex);
 _mainLogger.error(stackTrace);
 System.exit(1);

/**
 * Returns a {@link Container Container} that contains information of '{@code networkName}',
 * returns null if network '{@code networkName}' does not exist or the api key that is using has
 * no access to the network
 */
@Nullable
Container getNetwork(String networkName) {
 try {
  WebTarget webTarget =
    getTargetV2(Lists.newArrayList(CoordConstsV2.RSC_NETWORKS, networkName));
  Response response =
    webTarget
      .request(MediaType.APPLICATION_JSON)
      .header(CoordConstsV2.HTTP_HEADER_BATFISH_APIKEY, _settings.getApiKey())
      .header(CoordConstsV2.HTTP_HEADER_BATFISH_VERSION, Version.getVersion())
      .get();
  _logger.debug(response.getStatus() + " " + response.getStatusInfo() + " " + response + "\n");
  if (response.getStatus() != Response.Status.OK.getStatusCode()) {
   _logger.errorf("getNetwork: Did not get OK response. Got: %s\n", response.getStatus());
   _logger.error(response.readEntity(String.class) + "\n");
   return null;
  }
  String containerStr = response.readEntity(String.class);
  return BatfishObjectMapper.mapper().readValue(containerStr, Container.class);
 } catch (Exception e) {
  _logger.errorf("Exception in getNetwork from %s for %s\n", _coordWorkMgrV2, networkName);
  _logger.error(Throwables.getStackTraceAsString(e) + "\n");
  return null;
 }
}

private void printWorkStatusResponse(
  Pair<WorkStatusCode, String> response, boolean unconditionalPrint) {
 if (unconditionalPrint || _logger.getLogLevel() >= BatfishLogger.LEVEL_INFO) {
  WorkStatusCode status = response.getFirst();
  _logger.outputf("status: %s\n", status);
   task = BatfishObjectMapper.mapper().readValue(response.getSecond(), Task.class);
  } catch (IOException e) {
   _logger.errorf("Could not deserialize task object: %s\n", e);
   return;
   _logger.outputf(".... no task information\n");
   return;
    _logger.outputf(".... %s\n", batches.get(i));
   } else {
    _logger.debugf(".... %s\n", batches.get(i));
   _logger.outputf(".... %s: %s\n", task.getTerminated(), status);

private void unsetTestrig(boolean doDelta) {
 if (doDelta) {
  _currDeltaTestrig = null;
  _logger.info("Reference snapshot is now unset\n");
 } else {
  _currTestrig = null;
  _logger.info("Current snapshot is now unset\n");
 }
}

private synchronized int executeUpdate(PreparedStatement update) {
 int triesLeft = MAX_DB_TRIES;
 String updateString = update.toString();
 while (triesLeft > 0) {
  triesLeft--;
  try {
   _logger.debugf("Executing SQL update: %s\n", updateString);
   return update.executeUpdate();
  } catch (SQLException e) {
   _logger.errorf("SQLException while executing query '%s': %s", updateString, e.getMessage());
   _logger.errorf("Tries left = %d\n", triesLeft);
   if (triesLeft > 0) {
    try {
     if (!_dbConn.isValid(DB_VALID_CHECK_TIMEOUT_SECS)) {
      openDbConnection();
     }
    } catch (SQLException e1) {
     return 0;
    }
   }
  }
 }
 return 0;
}

private void checkProcessCommandErrorMessage(
  Command command, String[] parameters, String expected) throws Exception {
 Client client = new Client(new String[] {"-runmode", "gendatamodel"});
 File tempFile = _folder.newFile("writer");
 FileWriter writer = new FileWriter(tempFile);
 client._logger = new BatfishLogger("output", false);
 String[] args = ArrayUtils.addAll(new String[] {command.commandName()}, parameters);
 assertFalse(client.processCommand(args, writer));
 assertThat(client.getLogger().getHistory().toString(500), equalTo(expected));
 writer.close();
}

 @FormDataParam(CoordConsts.SVC_KEY_NETWORK_NAME) String networkName) {
try {
 _logger.infof("WMS:listSnapshots %s %s\n", apiKey, networkName);
   _logger.warnf(
     "Error listing snapshot %s in network %s: %s",
     networkName, snapshot, Throwables.getStackTraceAsString(e));
 _logger.errorf(
   "WMS:listSnapshots exception for apikey:%s in network:%s; exception:%s",
   apiKey, networkName, Throwables.getStackTraceAsString(e));

@Override
public boolean isValidWorkApiKey(String apiKey) {
 Users allUsers = loadUsers();
 boolean validUser = allUsers.users.stream().anyMatch(u -> apiKey.equals(u.apikey));
 _logger.infof("Authorizer: %s is %s valid API key\n", apiKey, validUser ? "a" : "NOT a");
 return validUser;
}

private boolean processCommand(String command) {
 String line = command.trim();
 if (line.length() == 0 || line.startsWith("#")) {
  return true;
 }
 _logger.debugf("Doing command: %s\n", line);
 String[] words = line.split("\\s+");
 return processCommand(words, null);
}

private void saveSolverInput(Expr expr) {
 // synchronize to avoid z3 concurrency bugs.
 // use NodJob to synchronize with any other similar writers.
 synchronized (NodJob.class) {
  Path nodPath =
    _settings
      .getActiveTestrigSettings()
      .getBasePath()
      .resolve(
        String.format(
          "solverInput-%s-%d.smt2", Instant.now(), Thread.currentThread().getId()));
  try (FileWriter writer = new FileWriter(nodPath.toFile())) {
   writer.write(expr.toString());
  } catch (IOException e) {
   _logger.warnf("Error saving Nod program to file: %s", Throwables.getStackTraceAsString(e));
  }
 }
}

 @Override
 public void run() {
  try {
   org.batfish.main.Driver.main(argArray, _logger);
  } catch (Exception e) {
   _logger.errorf(
     "Initialization of batfish failed with args: %s\nExceptionMessage: %s\n",
     Arrays.toString(argArray), e.getMessage());
  }
 }
};