How to use com.emc.ecs.sync.rest

private void resume(int jobId) {
  JobControl control = new JobControl();
  control.setStatus(JobControlStatus.Running);
  controlJob(jobId, control);
}

private void setThreadCount(int jobId, Integer threadCount) {
  JobControl control = new JobControl();
  if (threadCount != null) {
    control.setThreadCount(threadCount);
  }
  controlJob(jobId, control);
}

@Override
public void run() {
  try {
    // header
    writeCsvRow((Object[]) getHeaders());
    // rows
    for (T record : records) {
      writeCsvRow((Object[]) getColumns(record));
    }
    writer.flush();
  } catch (Throwable t) {
    error = t;
  } finally {
    try {
      writer.close();
    } catch (Throwable t) {
      log.warn("could not close writer", t);
    }
  }
}

@After
public void stopRestServer() throws InterruptedException {
  if (restServer != null) restServer.stop(0);
  restServer = null;
  // wait for all jobs to stop to prevent leakage into other tests
  for (JobInfo jobInfo : SyncJobService.getInstance().getAllJobs().getJobs()) {
    while (!SyncJobService.getInstance().getJobControl(jobInfo.getJobId()).getStatus().isFinalState())
      Thread.sleep(500);
    SyncJobService.getInstance().deleteJob(jobInfo.getJobId(), false);
  }
}

@GET
@Produces(MediaType.APPLICATION_XML)
public HostInfo get() {
  OperatingSystemMXBean osBean = (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
  HostInfo hostInfo = new HostInfo();
  hostInfo.setEcsSyncVersion(EcsSync.VERSION == null ? "Unreleased" : EcsSync.VERSION);
  hostInfo.setHostCpuCount(Runtime.getRuntime().availableProcessors());
  hostInfo.setHostCpuLoad(osBean.getSystemCpuLoad());
  hostInfo.setHostTotalMemory(osBean.getTotalPhysicalMemorySize());
  hostInfo.setHostMemoryUsed(hostInfo.getHostTotalMemory() - osBean.getFreePhysicalMemorySize());
  hostInfo.setLogLevel(SyncJobService.getInstance().getLogLevel());
  return hostInfo;
}

private void hostInfo() {
  Client client = new Client();
  HostInfo info = client.resource(endpoint + "/host").accept("application/xml").get(HostInfo.class);
  System.out.println("Host Info");
  System.out.println("-----------------------");
  System.out.println("ECS-Sync version: " + info.getEcsSyncVersion());
  System.out.println("CPU Count: " + info.getHostCpuCount());
  System.out.println("CPU Load: " + info.getHostCpuLoad());
  System.out.println("Total Memory: " + simpleSize(info.getHostTotalMemory()));
  System.out.println("Used Memory: " + simpleSize(info.getHostMemoryUsed()));
  System.out.println("Log Level: " + info.getLogLevel());
}

public JobControl getJobControl(int jobId) {
  EcsSync sync = syncCache.get(jobId);
  if (sync == null) return null;
  JobControl jobControl = new JobControl();
  jobControl.setStatus(getJobStatus(sync));
  jobControl.setThreadCount(sync.getSyncConfig().getOptions().getThreadCount());
  return jobControl;
}

private void listJobs() {
  Client client = new Client();
  JobList list = client.resource(endpoint + "/job").accept("application/xml").get(JobList.class);
  System.out.printf("JobID  Status\n");
  System.out.printf("-----------------------\n");
  for(JobInfo ji : list.getJobs()) {
    System.out.printf("%5d  %s\n", ji.getJobId(), ji.getStatus());
  }
}

public JobList getAllJobs() {
  JobList jobList = new JobList();
  for (Map.Entry<Integer, EcsSync> entry : syncCache.entrySet()) {
    jobList.getJobs().add(new JobInfo(entry.getKey(), getJobStatus(entry.getValue()),
        configCache.get(entry.getKey()), getProgress(entry.getKey())));
  }
  return jobList;
}

public void setJobControl(int jobId, JobControl jobControl) {
  EcsSync sync = syncCache.get(jobId);
  if (sync == null) throw new JobNotFoundException("the specified job ID does not exist");
  if (jobControl.getThreadCount() > 0) {
    sync.setThreadCount(jobControl.getThreadCount());
  }
  if (jobControl.getStatus() != null) {
    switch (jobControl.getStatus()) {
      case Stopped:
        sync.terminate();
        break;
      case Paused:
        sync.pause();
        break;
      case Running:
        sync.resume();
        break;
    }
  }
}

@Before
public void startRestServer() {
  // first, hush up the JDK logger (why does this default to INFO??)
  LogManager.getLogManager().getLogger("").setLevel(Level.WARNING);
  restServer = new RestServer(endpoint.getHost(), endpoint.getPort());
  restServer.start();
}

@Test
public void testGetJob() throws Exception {
  SyncConfig syncConfig = new SyncConfig();
  syncConfig.setSource(new TestConfig().withObjectCount(10).withMaxSize(10240).withDiscardData(false));
  syncConfig.setTarget(new TestConfig().withReadData(true).withDiscardData(false));
  // create sync job
  ClientResponse response = client.resource(endpoint).path("/job").put(ClientResponse.class, syncConfig);
  String jobId = response.getHeaders().getFirst("x-emc-job-id");
  try {
    Assert.assertEquals(response.getEntity(String.class), 201, response.getStatus());
    response.close(); // must close all responses
    // get job
    SyncConfig syncConfig2 = client.resource(endpoint).path("/job/" + jobId).get(SyncConfig.class);
    Assert.assertNotNull(syncConfig2);
    Assert.assertEquals(syncConfig, syncConfig2);
    // wait for job to complete
    while (!client.resource(endpoint).path("/job/" + jobId + "/control").get(JobControl.class).getStatus().isFinalState()) {
      Thread.sleep(1000);
    }
  } finally {
    // delete job
    response = client.resource(endpoint).path("/job/" + jobId).delete(ClientResponse.class);
    if (response.getStatus() != 200)
      log.warn("could not delete job: {}", response.getEntity(String.class));
    response.close(); // must close all responses
  }
}

@Test
public void testWriterFailure() throws Exception {
  // create a writer that will fail immediately
  AbstractCsvWriter csvWriter = new MyCsvWriter(failingList);
  Thread thread = new Thread(csvWriter);
  thread.setDaemon(true); // make sure thread dies when our test is done
  thread.start();
  // read from it
  long start = System.currentTimeMillis();
  byte[] bytes = StreamUtil.readAsBytes(csvWriter.getReadStream());
  Assert.assertEquals(22, bytes.length);
  Assert.assertNotNull(csvWriter.getError());
  Assert.assertEquals(FAIL_MESSAGE, csvWriter.getError().getMessage());
  // make sure it fails within a couple seconds
  Assert.assertTrue(System.currentTimeMillis() - start < 2000);
}

@GET
@Path("{jobId}/errors.csv")
@Produces("text/csv")
public Response getErrors(@PathParam("jobId") int jobId) throws IOException {
  if (!SyncJobService.getInstance().jobExists(jobId)) throw new NotFoundException(); // job not found
  ErrorReportWriter reportWriter = new ErrorReportWriter(SyncJobService.getInstance().getSyncErrors(jobId));
  Thread writerThread = new Thread(reportWriter);
  writerThread.setDaemon(true);
  writerThread.start();
  return Response.ok(reportWriter.getReadStream()).build();
}

  @GET
  @Path("{jobId}/all-objects-report.csv")
  @Produces("text/csv")
  public Response getCompleteReport(@PathParam("jobId") int jobId) throws IOException {
    if (!SyncJobService.getInstance().jobExists(jobId)) throw new NotFoundException(); // job not found

    DbDumpWriter reportWriter = new DbDumpWriter(SyncJobService.getInstance().getAllRecords(jobId));

    Thread writerThread = new Thread(reportWriter);
    writerThread.setDaemon(true);
    writerThread.start();

    return Response.ok(reportWriter.getReadStream()).build();
  }
}

private void writeCsvRow(Object... values) throws IOException {
  for (int i = 0; i < values.length; i++) {
    if (i > 0) writer.write(",");
    if (values[i] != null) writer.write("\"" + escape(values[i].toString()) + "\"");
  }
  writer.write("\n");
}

@Before
public void createClient() throws Exception {
  ClientConfig cc = new DefaultClientConfig();
  cc.getSingletons().add(new PluginResolver());
  client = Client.create(cc);
}

Assert.assertEquals(3, jobList.getJobs().size());
Assert.assertEquals(new Integer(jobId1), jobList.getJobs().get(0).getJobId());
Assert.assertEquals(new Integer(jobId2), jobList.getJobs().get(1).getJobId());
Assert.assertEquals(new Integer(jobId3), jobList.getJobs().get(2).getJobId());
while (!client.resource(endpoint).path("/job/" + jobId1 + "/control").get(JobControl.class).getStatus().isFinalState()
    && !client.resource(endpoint).path("/job/" + jobId2 + "/control").get(JobControl.class).getStatus().isFinalState()
    && !client.resource(endpoint).path("/job/" + jobId3 + "/control").get(JobControl.class).getStatus().isFinalState()) {
  Thread.sleep(1000);

private void pause(int jobId) {
  JobControl control = new JobControl();
  control.setStatus(JobControlStatus.Paused);
  controlJob(jobId, control);
}

private void stop(int jobId) {
  JobControl control = new JobControl();
  control.setStatus(JobControlStatus.Stopped);
  controlJob(jobId, control);
}