How to use

WorkItemBuilder

in

org.batfish.common.util

List<WorkItem> getAutoWorkQueue(String networkName, String testrigName) {
 List<WorkItem> autoWorkQueue = new LinkedList<>();
 WorkItem parseWork = WorkItemBuilder.getWorkItemParse(networkName, testrigName);
 autoWorkQueue.add(parseWork);
 Set<String> analysisNames = listAnalyses(networkName, AnalysisType.ALL);
 for (String analysis : analysisNames) {
  WorkItem analyzeWork =
    WorkItemBuilder.getWorkItemRunAnalysis(
      analysis, networkName, testrigName, null, false, false);
  autoWorkQueue.add(analyzeWork);
 }
 return autoWorkQueue;
}

private boolean answerFile(
  Path questionFile, boolean isDifferential, boolean isDelta, FileWriter outWriter) {
 if (!Files.exists(questionFile)) {
  throw new BatfishException("Question file not found: " + questionFile);
 }
 String questionName = DEFAULT_QUESTION_PREFIX + "_" + UUID.randomUUID();
 // upload the question
 boolean resultUpload =
   _workHelper.uploadQuestion(
     _currContainerName,
     isDelta ? _currDeltaTestrig : _currTestrig,
     questionName,
     questionFile.toAbsolutePath().toString());
 if (!resultUpload) {
  return false;
 }
 _logger.debug("Uploaded question. Answering now.\n");
 // answer the question
 WorkItem wItemAs =
   WorkItemBuilder.getWorkItemAnswerQuestion(
     questionName,
     _currContainerName,
     _currTestrig,
     _currDeltaTestrig,
     isDifferential,
     isDelta);
 return execute(wItemAs, outWriter);
}

private boolean generateDataplane(
  @Nullable FileWriter outWriter, List<String> options, List<String> parameters) {
 if (!isValidArgument(options, parameters, 0, 0, 0, Command.GEN_DP)) {
  return false;
 }
 if (!isSetTestrig() || !isSetContainer(true)) {
  return false;
 }
 // generate the data plane
 WorkItem wItemGenDp =
   WorkItemBuilder.getWorkItemGenerateDataPlane(_currContainerName, _currTestrig);
 return execute(wItemGenDp, outWriter);
}

if (WorkItemBuilder.isParsingWorkItem(workItem)) {
 workType = WorkType.PARSING;
if (WorkItemBuilder.isDataplaningWorkItem(workItem)) {
 if (workType != WorkType.UNKNOWN) {
  throw new BatfishException("Cannot do composite work. Separate PARSING and DATAPLANING.");
if (WorkItemBuilder.isAnsweringWorkItem(workItem)) {
 if (workType != WorkType.UNKNOWN) {
  throw new BatfishException("Cannot do composite work. Separate ANSWER from other work.");
     getQuestion(
       workItem.getContainerName(),
       WorkItemBuilder.getQuestionName(workItem),
       WorkItemBuilder.getAnalysisName(workItem)));
 workType =
   question.getIndependent()
if (WorkItemBuilder.isAnalyzingWorkItem(workItem)) {
 if (workType != WorkType.UNKNOWN) {
  throw new BatfishException("Cannot do composite work. Separate ANALYZE from other work.");
 String aName = WorkItemBuilder.getAnalysisName(workItem);
 if (aName == null) {
  throw new BatfishException("Analysis name not provided for ANALYZE work");
    workItem.getTestrigName(),
    workItem.getRequestParams().get(BfConsts.ARG_DELTA_TESTRIG),
    WorkItemBuilder.isDifferential(workItem),

private boolean runAnalysis(
  @Nullable FileWriter outWriter,
  List<String> options,
  List<String> parameters,
  boolean delta,
  boolean differential) {
 Command command =
   differential
     ? Command.RUN_ANALYSIS_DIFFERENTIAL
     : delta ? Command.RUN_ANALYSIS_REFERENCE : Command.RUN_ANALYSIS;
 if (!isValidArgument(options, parameters, 0, 1, 1, command)) {
  return false;
 }
 if (!isSetContainer(true) || !isSetTestrig()) {
  return false;
 }
 String analysisName = parameters.get(0);
 // answer the question
 WorkItem wItemAs =
   WorkItemBuilder.getWorkItemRunAnalysis(
     analysisName, _currContainerName, _currTestrig, _currDeltaTestrig, delta, differential);
 return execute(wItemAs, outWriter);
}

WorkItem wItemParse = WorkItemBuilder.getWorkItemParse(_currContainerName, testrigName);

private boolean generateReferenceDataplane(
  @Nullable FileWriter outWriter, List<String> options, List<String> parameters) {
 if (!isValidArgument(options, parameters, 0, 0, 0, Command.GEN_REFERENCE_DP)) {
  return false;
 }
 if (!isDeltaReady() || !isSetTestrig() || !isSetContainer(true)) {
  return false;
 }
 WorkItem wItemGenDdp =
   WorkItemBuilder.getWorkItemGenerateDeltaDataPlane(
     _currContainerName, _currTestrig, _currDeltaTestrig);
 return execute(wItemGenDdp, outWriter);
}

@Test
public void testGetAutoWorkQueueSuggestedAnalysis() {
 String containerName = "myContainer";
 String testrigName = "myTestrig";
 _manager.initNetwork(containerName, null);
 // user policy
 _manager.configureAnalysis(
   containerName, true, "suggestedanalysis", Maps.newHashMap(), Lists.newArrayList(), true);
 WorkItem parseWorkItem = WorkItemBuilder.getWorkItemParse(containerName, testrigName);
 WorkItem analysisWorkItem =
   WorkItemBuilder.getWorkItemRunAnalysis(
     "suggestedanalysis", containerName, testrigName, null, false, false);
 List<WorkItem> workQueue = _manager.getAutoWorkQueue(containerName, testrigName);
 assertThat(workQueue, hasSize(2));
 // checking that the first work item is for parse
 assertThat(workQueue.get(0).matches(parseWorkItem), equalTo(true));
 // checking run analysis workitem
 assertThat(
   "Work Queue not correct for suggested analyses",
   workQueue.get(1).matches(analysisWorkItem),
   equalTo(true));
}

WorkItemBuilder.getWorkItemAnswerQuestion(
  questionName,
  _currContainerName,

private QueuedWork generateAndQueueDataplaneWork(String container, String testrig)
  throws Exception {
 WorkItem newWItem = WorkItemBuilder.getWorkItemGenerateDataPlane(container, testrig);
 WorkDetails details = new WorkDetails(testrig, null, false, WorkType.DATAPLANING);
 QueuedWork newWork = new QueuedWork(newWItem, details);
 boolean queued = queueUnassignedWork(newWork);
 if (!queued) {
  throw new BatfishException("Failed to auto-queue dataplane work");
 }
 return newWork;
}

@Test
public void testGetAutoWorkQueueUserAnalysis() {
 String containerName = "myContainer";
 String testrigName = "myTestrig";
 _manager.initNetwork(containerName, null);
 // user policy
 _manager.configureAnalysis(
   containerName, true, "useranalysis", Maps.newHashMap(), Lists.newArrayList(), false);
 WorkItem parseWorkItem = WorkItemBuilder.getWorkItemParse(containerName, testrigName);
 WorkItem analysisWorkItem =
   WorkItemBuilder.getWorkItemRunAnalysis(
     "useranalysis", containerName, testrigName, null, false, false);
 List<WorkItem> workQueue = _manager.getAutoWorkQueue(containerName, testrigName);
 assertThat(workQueue, hasSize(2));
 // checking that the first work item is for parse
 assertThat(workQueue.get(0).matches(parseWorkItem), equalTo(true));
 // checking run analysis workitem
 assertThat(
   "Work Queue not correct for user analyses",
   workQueue.get(1).matches(analysisWorkItem),
   equalTo(true));
}

public static WorkItem getWorkItemAnswerQuestion(
  String questionName,
  String containerName,
  String testrigName,
  String deltaTestrig,
  String analysisName,
  boolean isDifferential,
  boolean isDelta) {
 WorkItem wItem = new WorkItem(containerName, testrigName);
 wItem.addRequestParam(BfConsts.COMMAND_ANSWER, "");
 wItem.addRequestParam(BfConsts.ARG_QUESTION_NAME, questionName);
 if (isDifferential) {
  wItem.addRequestParam(BfConsts.ARG_DIFFERENTIAL, "");
 }
 if (deltaTestrig != null) {
  wItem.addRequestParam(BfConsts.ARG_DELTA_TESTRIG, deltaTestrig);
 }
 if (isDelta) {
  wItem.addRequestParam(BfConsts.ARG_DIFF_ACTIVE, "");
 }
 if (analysisName != null) {
  wItem.addRequestParam(BfConsts.ARG_ANALYSIS_NAME, analysisName);
 }
 return wItem;
}