javax.batch.runtime.BatchStatus Java Examples

/**
 * Waits until the end of the {@link javax.batch.runtime.JobExecution} with the given {@code id}
 * and returns the final {@link BatchStatus}.
 *
 * @param jobOperator the {@link JobOperator to use}
 * @param id of the {@link javax.batch.runtime.JobExecution} to wait for
 *
 * @return the final {@link BatchStatus} or in case of an {@link InterruptedException} the current {@link BatchStatus}
 *         will be returned.
 */
public static BatchStatus waitFor(JobOperator jobOperator, long id) {

    BatchStatus batchStatus;

    if (JobOperatorImpl.class.isInstance(jobOperator)) {
        JobOperatorImpl.class.cast(jobOperator).waitFor(id);
        batchStatus = getBatchStatus(jobOperator, id);
    } else {

        // else polling
        do {
            try {
                Thread.sleep(100);
                batchStatus = getBatchStatus(jobOperator, id);
            } catch (final InterruptedException e) {
                return getBatchStatus(jobOperator, id);
            }
        }
        while (!isDone(batchStatus));
    }

    return batchStatus;
}
 

/**
 * We need to keep the test running because JobOperator runs the batch job in an asynchronous way, so the
 * JobExecution can be properly updated with the running job status.
 *
 * @param jobOperator the JobOperator of the job that is being executed.
 * @throws java.util.concurrent.TimeoutException if the job takes a long time to complete.
 */
public static JobExecution keepTestAlive(JobOperator jobOperator, Long executionId) throws TimeoutException {
    JobExecution jobExecution = jobOperator.getJobExecution(executionId);

    Date curDate = new Date();
    BatchStatus curBatchStatus = jobExecution.getBatchStatus();

    while (true) {
        if (curBatchStatus == BatchStatus.STOPPED ||
            curBatchStatus == BatchStatus.COMPLETED ||
            curBatchStatus == BatchStatus.FAILED) {
            break;
        }

        if (new Date().getTime() - curDate.getTime() > 1000000) {
            throw new TimeoutException("Job processing did not complete in time");
        }

        jobExecution = jobOperator.getJobExecution(executionId);
        curBatchStatus = jobExecution.getBatchStatus();
    }
    return jobExecution;
}
 

@Override
public Serializable collectPartitionData() throws Exception {
    TransientUserData transientUserData  = (TransientUserData)stepCtx.getTransientUserData();
    BatchStatus batchStatus = stepCtx.getBatchStatus();

    // If the job is being stopped or in other status except for "started", or if there is more page to process, then collect nothing.
    if (!batchStatus.equals(BatchStatus.STARTED)
        || transientUserData.isMoreToExport()
        || transientUserData.getResourceTypeSummary() == null)
    {
        return null;
    }

    CheckPointUserData partitionSummary = CheckPointUserData.fromTransientUserData(transientUserData);
    return partitionSummary;
}
 

@Test
public void testPartitionPropertyResolverForMapper() throws Exception {
       final JobOperator op = BatchRuntime.getJobOperator();
       Properties jobParams = new Properties();
       jobParams.setProperty(STEP_PROP, STEP_PROP_VAL);
	final long id = op.start("partition-propertyResolver", jobParams);
       Batches.waitForEnd(op, id);

	assertEquals(op.getJobExecution(id).getBatchStatus(), BatchStatus.COMPLETED);

	String exitStatus = op.getJobExecution(id).getExitStatus();

	Properties props = PropertyHelper.stringToProperties(exitStatus);

	String valFromStepProp = props.getProperty(STEP_CONTEXT_PROPERTY);
	String valFromSubstitution = props.getProperty(SUBSTITUTION_PROPERTY);
	assertEquals(valFromStepProp, STEP_PROP_VAL, "Compare values from step-level property with param used in substitution");
	assertEquals(valFromSubstitution, STEP_PROP_VAL, "Compare values from step-level property with a collector-property using this step-level property via a 'jobProperties' substitution.");
}
 

private void persistJobBatchAndExitStatus() {
    BatchStatus batchStatus = jobContext.getBatchStatus();

    // Take a current timestamp for last updated no matter what the status.
    long time = System.currentTimeMillis();
    Timestamp timestamp = new Timestamp(time);
    jobExecution.setLastUpdateTime(timestamp);

    // Perhaps these should be coordinated in a tran but probably better still would be
    // rethinking the table design to let the database provide us consistently with a single update.
    jobStatusService.updateJobBatchStatus(jobInstanceId, batchStatus);
    jobStatusService.updateJobExecutionStatus(jobExecution.getInstanceId(), jobContext.getBatchStatus(), jobContext.getExitStatus());

    if (batchStatus.equals(BatchStatus.COMPLETED) || batchStatus.equals(BatchStatus.STOPPED) ||
        batchStatus.equals(BatchStatus.FAILED)) {

        jobExecution.setEndTime(timestamp);
        persistenceService.updateWithFinalExecutionStatusesAndTimestamps(jobExecution.getExecutionId(),
            batchStatus, jobContext.getExitStatus(), timestamp);
    } else {
        throw new IllegalStateException("Not expected to encounter batchStatus of " + batchStatus + " at this point.  Aborting.");
    }
}
 

@Override
public Set<Long> jobOperatorGetRunningExecutions(String jobName) {
    Connection conn = null;
    PreparedStatement statement = null;
    ResultSet rs = null;

    final Set<Long> executionIds = new HashSet<Long>();
    try {
        conn = getConnection();
        statement = conn.prepareStatement(dictionary.getFindRunningJobExecutions());
        statement.setString(1, BatchStatus.STARTED.name());
        statement.setString(2, BatchStatus.STARTING.name());
        statement.setString(3, BatchStatus.STOPPING.name());
        statement.setString(4, jobName);
        rs = statement.executeQuery();
        while (rs.next()) {
            executionIds.add(rs.getLong(dictionary.jobExecutionColumns(0)));
        }

    } catch (final SQLException e) {
        throw new PersistenceException(e);
    } finally {
        cleanupConnection(conn, rs, statement);
    }
    return executionIds;
}
 

@Test
public void stop() throws Exception {
    final StopMojo mojo = mojo(StopMojo.class);

    final long id = mojo.getOrCreateOperator().start("simple", new Properties() {{ setProperty("sleep", "5000"); }});
    JobExecution jobExecution;
    do {
        jobExecution = mojo.getOrCreateOperator().getJobExecution(id);
    } while (!BatchStatus.STARTED.equals(jobExecution.getBatchStatus()));

    mojo.executionId = id;
    mojo.execute();

    Batches.waitForEnd(id);

    final String output = BatchEEMojoTestFactory.output(mojo);
    assertEquals(BatchStatus.STOPPED, mojo.getOrCreateOperator().getJobExecution(Long.parseLong(output.substring(output.lastIndexOf("#") + 1).trim())).getBatchStatus());
    assertTrue(output.toLowerCase(Locale.ENGLISH).contains("stopped"));
}
 

private void updateStepExecutionInstanceData(final Structures.ExecutionInstanceData exec,
                                                 final String batchStatus,final  String exitStatus, final String stepName,
                                                 final long readCount, final long writeCount, final long commitCount, final long rollbackCount,
                                                 final long readSkipCount, final long processSkipCount, final long filterCount, final long writeSkipCount,
                                                 final Timestamp startTime, final Timestamp endTime,
                                                 final Serializable persistentData,
                                                 final Structures.StepExecutionInstanceData stepExecutionInstanceData) {
//CHECKSTYLE:ON
        stepExecutionInstanceData.jobExec = exec;
        stepExecutionInstanceData.execution.setExitStatus(exitStatus);
        stepExecutionInstanceData.execution.setBatchStatus(BatchStatus.valueOf(batchStatus));
        stepExecutionInstanceData.execution.setRollbackCount(rollbackCount);
        stepExecutionInstanceData.execution.setStepName(stepName);
        stepExecutionInstanceData.execution.setReadCount(readCount);
        stepExecutionInstanceData.execution.setWriteCount(writeCount);
        stepExecutionInstanceData.execution.setCommitCount(commitCount);
        stepExecutionInstanceData.execution.setRollbackCount(rollbackCount);
        stepExecutionInstanceData.execution.setReadSkipCount(readSkipCount);
        stepExecutionInstanceData.execution.setProcessSkipCount(processSkipCount);
        stepExecutionInstanceData.execution.setWriteSkipCount(writeSkipCount);
        stepExecutionInstanceData.execution.setFilterCount(filterCount);
        stepExecutionInstanceData.execution.setWriteSkipCount(writeSkipCount);
        stepExecutionInstanceData.execution.setStartTime(startTime);
        stepExecutionInstanceData.execution.setEndTime(endTime);
        stepExecutionInstanceData.execution.setPersistentUserData(persistentData);
    }
 

public void markJobStarted(final long key, final Timestamp startTS) {
    Connection conn = null;
    PreparedStatement statement = null;

    try {
        conn = getConnection();
        statement = conn.prepareStatement(dictionary.getUpdateStartedJobExecution());

        statement.setString(1, BatchStatus.STARTED.name());
        statement.setTimestamp(2, startTS);
        statement.setTimestamp(3, startTS);
        statement.setLong(4, key);

        statement.executeUpdate();
        if (!conn.getAutoCommit()) {
            conn.commit();
        }
    } catch (final SQLException e) {
        throw new PersistenceException(e);
    } finally {
        cleanupConnection(conn, null, statement);
    }
}
 

@Test
public void givenChunk_thenBatch_CompletesWithSucess() throws Exception {
    JobOperator jobOperator = BatchRuntime.getJobOperator();
    Long executionId = jobOperator.start("simpleChunk", new Properties());
    JobExecution jobExecution = jobOperator.getJobExecution(executionId);
    jobExecution = BatchTestHelper.keepTestAlive(jobExecution);
    List<StepExecution> stepExecutions = jobOperator.getStepExecutions(executionId);
    for (StepExecution stepExecution : stepExecutions) {
        if (stepExecution.getStepName()
            .equals("firstChunkStep")) {
            Map<Metric.MetricType, Long> metricsMap = BatchTestHelper.getMetricsMap(stepExecution.getMetrics());
            assertEquals(10L, metricsMap.get(Metric.MetricType.READ_COUNT)
                .longValue());
            assertEquals(10L / 2L, metricsMap.get(Metric.MetricType.WRITE_COUNT)
                .longValue());
            assertEquals(10L / 3 + (10L % 3 > 0 ? 1 : 0), metricsMap.get(Metric.MetricType.COMMIT_COUNT)
                .longValue());
        }
    }
    assertEquals(jobExecution.getBatchStatus(), BatchStatus.COMPLETED);
}
 

private Structures.ExecutionInstanceData createRuntimeJobExecutionEntry(final JobInstance jobInstance, final Properties jobParameters,
                                                                        final BatchStatus batchStatus, final Timestamp now) {
    final Structures.ExecutionInstanceData executionInstanceData = new Structures.ExecutionInstanceData();
    final long id = data.executionInstanceIdGenerator.getAndIncrement();
    executionInstanceData.execution = new JobExecutionImpl(id, jobInstance.getInstanceId(), this);
    executionInstanceData.execution.setExecutionId(id);
    executionInstanceData.execution.setInstanceId(jobInstance.getInstanceId());
    executionInstanceData.execution.setBatchStatus(batchStatus.name());
    executionInstanceData.execution.setCreateTime(now);
    executionInstanceData.execution.setLastUpdateTime(now);
    executionInstanceData.execution.setJobParameters(jobParameters);

    data.executionInstanceData.put(id, executionInstanceData);
    final Structures.JobInstanceData jobInstanceData = data.jobInstanceData.get(jobInstance.getInstanceId());
    synchronized (jobInstanceData.executions) {
        jobInstanceData.executions.add(executionInstanceData);
    }
    return executionInstanceData;
}
 

public static JobExecution keepTestStopped(JobExecution jobExecution) throws InterruptedException {
    int maxTries = 0;
    while (!jobExecution.getBatchStatus()
        .equals(BatchStatus.STOPPED)) {
        if (maxTries < MAX_TRIES) {
            maxTries++;
            Thread.sleep(THREAD_SLEEP);
            jobExecution = BatchRuntime.getJobOperator()
                .getJobExecution(jobExecution.getExecutionId());
        } else {
            break;
        }
    }
    Thread.sleep(THREAD_SLEEP);
    return jobExecution;
}
 

@Test
public void givenChunkError_thenErrorSkipped_CompletesWithSuccess() throws Exception {
    JobOperator jobOperator = BatchRuntime.getJobOperator();
    Long executionId = jobOperator.start("simpleErrorSkipChunk", new Properties());
    JobExecution jobExecution = jobOperator.getJobExecution(executionId);
    jobExecution = BatchTestHelper.keepTestAlive(jobExecution);
    List<StepExecution> stepExecutions = jobOperator.getStepExecutions(executionId);
    for (StepExecution stepExecution : stepExecutions) {
        if (stepExecution.getStepName()
            .equals("errorStep")) {
            jobOperator.getStepExecutions(executionId)
            .stream()
            .map(BatchTestHelper::getProcessSkipCount)
            .forEach(skipCount -> assertEquals(1L, skipCount.longValue()));
        }
    }
    assertEquals(jobExecution.getBatchStatus(), BatchStatus.COMPLETED);
}
 

public static JobExecution keepTestFailed(JobExecution jobExecution) throws InterruptedException {
    int maxTries = 0;
    while (!jobExecution.getBatchStatus()
        .equals(BatchStatus.FAILED)) {
        if (maxTries < MAX_TRIES) {
            maxTries++;
            Thread.sleep(THREAD_SLEEP);
            jobExecution = BatchRuntime.getJobOperator()
                .getJobExecution(jobExecution.getExecutionId());
        } else {
            break;
        }
    }
    Thread.sleep(THREAD_SLEEP);

    return jobExecution;
}
 

@Override
public void updateBatchStatusOnly(final long key, final BatchStatus batchStatus, final Timestamp updatets) {
    Connection conn = null;
    PreparedStatement statement = null;
    try {
        conn = getConnection();
        statement = conn.prepareStatement(dictionary.getUpdateJobExecution());
        statement.setString(1, batchStatus.name());
        statement.setTimestamp(2, updatets);
        statement.setLong(3, key);
        statement.executeUpdate();
        if (!conn.getAutoCommit()) {
            conn.commit();
        }
    } catch (final SQLException e) {
        e.printStackTrace();
        throw new PersistenceException(e);
    } finally {
        cleanupConnection(conn, null, statement);
    }
}
 

@Test
public void abandon() throws Exception {
    final AbandonMojo mojo = mojo(AbandonMojo.class);

    final long id = mojo.getOrCreateOperator().start("simple", new Properties() {{ setProperty("sleep", "0"); }});
    JobExecution jobExecution;
    do {
        jobExecution = mojo.getOrCreateOperator().getJobExecution(id);
    } while (!BatchStatus.COMPLETED.equals(jobExecution.getBatchStatus()));

    mojo.executionId = id;
    mojo.execute();

    Batches.waitForEnd(id);

    final String output = BatchEEMojoTestFactory.output(mojo);
    assertEquals(BatchStatus.ABANDONED, mojo.getOrCreateOperator().getJobExecution(Long.parseLong(output.substring(output.lastIndexOf("#") + 1).trim())).getBatchStatus());
    assertTrue(output.toLowerCase(Locale.ENGLISH).contains("abandonned"));
}
 

@Test
public void givenSplit_thenBatch_CompletesWithSuccess() throws Exception {
    JobOperator jobOperator = BatchRuntime.getJobOperator();
    Long executionId = jobOperator.start("splitJobSequence", new Properties());
    JobExecution jobExecution = jobOperator.getJobExecution(executionId);
    jobExecution = BatchTestHelper.keepTestAlive(jobExecution);
    List<StepExecution> stepExecutions = jobOperator.getStepExecutions(executionId);
    List<String> executedSteps = new ArrayList<>();
    for (StepExecution stepExecution : stepExecutions) {
        executedSteps.add(stepExecution.getStepName());
    }
    assertEquals(3, stepExecutions.size());
    assertTrue(executedSteps.contains("splitJobSequenceStep1"));
    assertTrue(executedSteps.contains("splitJobSequenceStep2"));
    assertTrue(executedSteps.contains("splitJobSequenceStep3"));
    assertTrue(executedSteps.get(0).equals("splitJobSequenceStep1") || executedSteps.get(0).equals("splitJobSequenceStep2"));
    assertTrue(executedSteps.get(1).equals("splitJobSequenceStep1") || executedSteps.get(1).equals("splitJobSequenceStep2"));
    assertTrue(executedSteps.get(2).equals("splitJobSequenceStep3"));
    assertEquals(jobExecution.getBatchStatus(), BatchStatus.COMPLETED);
}
 

@Test
public void testStopPartitionedBatch() throws Exception {

    JobOperator jobOperator = BatchRuntime.getJobOperator();
    long executionId = jobOperator.start("partition-stop", new Properties());

    do {
        log.info("Waiting til batch is started");
        Thread.sleep(50);
    }
    while (jobOperator.getJobExecution(executionId).getBatchStatus() != BatchStatus.STARTED);

    Thread.sleep(100);

    jobOperator.stop(executionId);

    BatchStatus status = Batches.waitFor(jobOperator, executionId);
    Assert.assertEquals(status, BatchStatus.STOPPED);
}
 

@Override
public void updateWithFinalExecutionStatusesAndTimestamps(final long key, final BatchStatus batchStatus, final String exitStatus, final Timestamp updatets) {
    final EntityManager em = emProvider.newEntityManager();
    try {
        final Object tx = txProvider.start(em);
        try {
            final JobExecutionEntity instance = em.find(JobExecutionEntity.class, key);
            instance.setBatchStatus(batchStatus);
            instance.setUpdateTime(updatets);
            instance.setEndTime(updatets);
            instance.setExitStatus(exitStatus);

            em.merge(instance);
            txProvider.commit(tx);
        } catch (final Exception e) {
            throw new BatchContainerRuntimeException(performRollback(tx, e));
        }
    } finally {
        emProvider.release(em);
    }
}
 

private void startStep() {
    // Update status
    statusStarting();
    //Set Step context properties
    setContextProperties();
    //Set up step artifacts like step listeners, partition reducers
    setupStepArtifacts();
    // Move batch status to started.
    updateBatchStatus(BatchStatus.STARTED);

    long time = System.currentTimeMillis();
    Timestamp startTS = new Timestamp(time);
    stepContext.setStartTime(startTS);

    persistenceManagerService.updateStepExecution(rootJobExecutionId, stepContext);
}
 

@Override
public void updateBatchStatusOnly(final long executionId, final BatchStatus batchStatus, final Timestamp timestamp) {
    final EntityManager em = emProvider.newEntityManager();
    try {
        final Object tx = txProvider.start(em);
        final JobExecutionEntity instance = em.find(JobExecutionEntity.class, executionId);
        instance.setBatchStatus(batchStatus);
        instance.setUpdateTime(timestamp);

        try {
            em.merge(instance);
            txProvider.commit(tx);
        } catch (final Exception e) {
            throw new BatchContainerRuntimeException(performRollback(tx, e));
        }
    } finally {
        emProvider.release(em);
    }
}
 

public static JobExecution keepTestAlive(JobExecution jobExecution) throws InterruptedException {
    int maxTries = 0;
    while (!jobExecution.getBatchStatus()
        .equals(BatchStatus.COMPLETED)) {
        if (maxTries < MAX_TRIES) {
            maxTries++;
            Thread.sleep(THREAD_SLEEP);
            jobExecution = BatchRuntime.getJobOperator()
                .getJobExecution(jobExecution.getExecutionId());
        } else {
            break;
        }
    }
    Thread.sleep(THREAD_SLEEP);
    return jobExecution;
}
 

@Override
public BatchStatus getBatchStatus() {
    if (this.jobContext != null) {
        return this.jobContext.getBatchStatus();
    } else {
        // old job, retrieve from the backend
        final String name = persistenceManagerService.jobOperatorQueryJobExecutionBatchStatus(executionID);
        if (name != null) {
            return BatchStatus.valueOf(name);
        }
    }
    return BatchStatus.valueOf(batchStatus);
}
 

@Override
public RuntimeJobExecution createJobExecution(final JobInstance jobInstance, final Properties jobParameters, final BatchStatus batchStatus) {
    final Timestamp now = new Timestamp(System.currentTimeMillis());
    final long newExecutionId = createRuntimeJobExecutionEntry(jobInstance, jobParameters, batchStatus, now);
    final RuntimeJobExecution jobExecution = new RuntimeJobExecution(jobInstance, newExecutionId, this);
    jobExecution.setBatchStatus(batchStatus.name());
    jobExecution.setCreateTime(now);
    jobExecution.setLastUpdateTime(now);
    return jobExecution;
}
 

@Test
public void batchletWithConfigFromJobParams() {
    final StepExecution execution = StepLauncher.execute(
            StepBuilder.newBatchlet()
                    .ref(BATCHLET_REF)
                    .property("config", "#{jobParameters['conf']}")
                    .create(),
            new Properties() {{
                setProperty("conf", "param");
            }});
    assertEquals("param", execution.getExitStatus());
    assertEquals(BatchStatus.COMPLETED, execution.getBatchStatus());
}
 

@Test
public void configuredReader() {
    final StepExecution execution = StepLauncher.execute(StepBuilder.newChunk()
            .reader().ref(SimpleReader.class.getName()).property("total", "1")
            .writer().ref(SimpleWriter.class.getName())
            .create());
    assertEquals(BatchStatus.COMPLETED, execution.getBatchStatus());
    assertNotNull(SimpleWriter.result);
    assertEquals(1, SimpleWriter.result.size());
    assertTrue(SimpleWriter.result.contains("#0"));
}
 

@Override
public void stop() {
    stepContext.setBatchStatus(BatchStatus.STOPPING);

    // we don't need to call stop on the chunk implementation here since a
    // chunk always returns control to
    // the batch container after every item.

}
 

@Override
public RuntimeFlowInSplitExecution createFlowInSplitExecution(final JobInstance jobInstance, final BatchStatus batchStatus) {
    final EntityManager em = emProvider.newEntityManager();
    try {
        final JobExecutionEntity instance = new JobExecutionEntity();
        instance.setCreateTime(new Timestamp(System.currentTimeMillis()));
        instance.setUpdateTime(instance.getCreateTime());
        instance.setBatchStatus(batchStatus);

        final Object tx = txProvider.start(em);
        try {
            instance.setInstance(em.find(JobInstanceEntity.class, jobInstance.getInstanceId()));

            em.persist(instance);
            txProvider.commit(tx);

            final RuntimeFlowInSplitExecution jobExecution = new RuntimeFlowInSplitExecution(jobInstance, instance.getExecutionId(), this);
            jobExecution.setBatchStatus(batchStatus.name());
            jobExecution.setCreateTime(instance.getCreateTime());
            jobExecution.setLastUpdateTime(instance.getCreateTime());
            return jobExecution;
        } catch (final Exception e) {
            throw new BatchContainerRuntimeException(performRollback(tx, e));
        }
    } finally {
        emProvider.release(em);
    }
}
 

public JobStatus(JobInstance jobInstance) {
    this.batchStatus = BatchStatus.STARTING;
    //this.restartCount = 0;
    // this.updateCount = 0;
    this.jobInstance = jobInstance;
    this.jobInstanceId = jobInstance.getInstanceId();
}
 

@Override
public StepStatus getStepStatus(final long instanceId, final String stepName) {
    Connection conn = null;
    PreparedStatement statement = null;
    ResultSet rs = null;

    try {
        conn = getConnection();
        statement = conn.prepareStatement(dictionary.getFindStepExecutionByJobInstanceAndStepName());
        statement.setLong(1, instanceId);
        statement.setString(2, stepName);
        rs = statement.executeQuery();
        if (rs.next()) {
            final int startCount = rs.getInt(dictionary.stepExecutionColumns(13));
            final long id = rs.getLong(dictionary.stepExecutionColumns(0));
            final StepStatus stepStatus = new StepStatus(id, startCount);
            final int numPartitions = rs.getInt(dictionary.stepExecutionColumns(7));
            final byte[] persistentDatas = rs.getBytes(dictionary.stepExecutionColumns(8));
            if (numPartitions >= 0) {
                stepStatus.setNumPartitions(numPartitions);
            }
            if (persistentDatas != null) {
                stepStatus.setPersistentUserData(new PersistentDataWrapper(persistentDatas));
            }
            stepStatus.setBatchStatus(BatchStatus.valueOf(rs.getString(dictionary.stepExecutionColumns(1))));
            stepStatus.setExitStatus(rs.getString(dictionary.stepExecutionColumns(4)));
            stepStatus.setLastRunStepExecutionId(rs.getLong(dictionary.stepExecutionColumns(6)));
            stepStatus.setStepExecutionId(id);
            return stepStatus;
        }
        return null;
    } catch (final SQLException e) {
        throw new PersistenceException(e);
    } finally {
        cleanupConnection(conn, rs, statement);
    }
}