public static void main(String[] args) throws Exception {
    ClientResource resource = new ClientResource("http://localhost:8111/");

    // Get a representation
    Representation rep = resource.get();
    System.out.println(resource.getStatus());

    // Get an updated representation, if modified
    resource.getConditions().setModifiedSince(rep.getModificationDate());
    rep = resource.get();
    System.out.println(resource.getStatus());

    // Get an updated representation, if tag changed
    resource.getConditions().setModifiedSince(null);
    resource.getConditions().getNoneMatch().add(new Tag("xyz123"));
    rep = resource.get();
    System.out.println(resource.getStatus());

    // Put a new representation if tag has not changed
    resource.getConditions().getNoneMatch().clear();
    resource.getConditions().getMatch().add(rep.getTag());
    resource.put(rep);
    System.out.println(resource.getStatus());

    // Put a new representation when a different tag
    resource.getConditions().getMatch().clear();
    resource.getConditions().getMatch().add(new Tag("abcd7890"));
    resource.put(rep);
    System.out.println(resource.getStatus());
  }
  /**
   * Assert if the FileOrdered have been copied It gets the list of files from the order, and gets
   * the file described in the list of files
   *
   * @param order the order to assert
   * @param nbFileCopied the expected number of files to be copied
   */
  private void assertFileOrderedExists(Order order, int nbFileCopied) {
    assertNotNull(order);
    assertNotNull(order.getResourceCollection());

    assertEquals(1, order.getResourceCollection().size());
    Representation result = null;
    try {

      String res = order.getResourceCollection().get(0);

      ClientResource cr = new ClientResource(res);

      ChallengeResponse chal =
          new ChallengeResponse(ChallengeScheme.HTTP_BASIC, userLogin, password);

      cr.setChallengeResponse(chal);

      result = cr.get(getMediaTest());

      assertNotNull(result);
      assertTrue(cr.getStatus().isSuccess());

      try {
        // get the list of files
        String text = result.getText();
        String[] contents = text.split("\r\n");
        assertNotNull(contents);
        assertEquals(nbFileCopied, contents.length);
        Reference content = new Reference(contents[0]);
        // asserts
        assertNotNull(content);
        assertNotSame("", content.toString());
        // get the file corresponding to the first url, check that this file
        // exists
        cr = new ClientResource(content);

        chal = new ChallengeResponse(ChallengeScheme.HTTP_BASIC, userLogin, password);

        cr.setChallengeResponse(chal);

        result = cr.get(getMediaTest());
        assertNotNull(result);
        assertTrue(cr.getStatus().isSuccess());

      } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
      } finally {
        RIAPUtils.exhaust(result);
      }

    } finally {
      RIAPUtils.exhaust(result);
    }
  }
  @Test
  public void testGetProbabilities() throws ResourceException, IOException {
    final Reference reference = new Reference("http://localhost/clue/probability.json");
    reference.setHostPort(port);

    final ClientResource resource = new ClientResource(reference);
    resource.setProtocol(Protocol.HTTP);
    resource.setChallengeResponse(getChallengeResponse());

    System.out.println(resource.get().getText());
    final ProbabilityReport report = resource.get(ProbabilityReport.class);
    System.out.println(report.getMostLikelyRoom().getCardProbability());
    resource.release();
  }
  /**
   * Invoke GET
   *
   * @param uri String
   * @param params String
   * @param parameters Map<String, String>
   * @param uriTemplate String
   */
  public void retrieveDocAPI(
      String uri,
      String params,
      Map<String, String> parameters,
      String uriTemplate,
      ChallengeResponse challengeResponse) {
    ClientResource cr = new ClientResource(uri);
    cr.setChallengeResponse(challengeResponse);

    System.out.println("URI: " + uriTemplate);
    Representation result = cr.get(docAPI.getMediaTest());
    docAPI.appendSection("Format");
    // url type
    // request
    ClientResource crLocal = new ClientResource(uri);
    docAPI.appendRequest(Method.GET, crLocal);
    // parameters
    docAPI.appendParameters(parameters);
    docAPI.appendSection("Example");
    docAPI.appendRequest(Method.GET, cr);
    // response
    docAPI.appendResponse(result);

    RIAPUtils.exhaust(result);
  }
  @Test
  public void testErrorSearchRdfWithoutSearchTerm() throws Exception {
    // prepare:
    final InferredOWLOntologyID testArtifact =
        this.loadTestArtifact(
            TestConstants.TEST_ARTIFACT_20130206, MediaType.APPLICATION_RDF_TURTLE);

    final ClientResource searchClientResource =
        new ClientResource(this.getUrl(PoddWebConstants.PATH_SEARCH));

    // there is no need to authenticate or have a test artifact as the
    // search term is checked
    // for first
    try {
      // no search term!
      searchClientResource.addQueryParameter(
          PoddWebConstants.KEY_ARTIFACT_IDENTIFIER, testArtifact.getOntologyIRI().toString());
      searchClientResource.addQueryParameter(
          PoddWebConstants.KEY_SEARCH_TYPES, "http://purl.org/podd/ns/poddScience#Platform");

      searchClientResource.get(MediaType.APPLICATION_RDF_XML);
      Assert.fail("Should have thrown a ResourceException");
    } catch (final ResourceException e) {
      Assert.assertEquals(Status.CLIENT_ERROR_BAD_REQUEST, e.getStatus());
    } finally {
      this.releaseClient(searchClientResource);
    }
  }
  /** Test getting a task variable. GET runtime/tasks/{taskId}/variables/{variableName}/data */
  public void testGetTaskVariableDataSerializable() throws Exception {
    try {
      TestSerializableVariable originalSerializable = new TestSerializableVariable();
      originalSerializable.setSomeField("This is some field");

      // Test variable behaviour on standalone tasks
      Task task = taskService.newTask();
      taskService.saveTask(task);
      taskService.setVariableLocal(task.getId(), "localTaskVariable", originalSerializable);

      ClientResource client =
          getAuthenticatedClient(
              RestUrls.createRelativeResourceUrl(
                  RestUrls.URL_TASK_VARIABLE_DATA, task.getId(), "localTaskVariable"));
      client.get();
      assertEquals(Status.SUCCESS_OK, client.getResponse().getStatus());

      // Read the serializable from the stream
      ObjectInputStream stream =
          new ObjectInputStream(client.getResponse().getEntity().getStream());
      Object readSerializable = stream.readObject();
      assertNotNull(readSerializable);
      assertTrue(readSerializable instanceof TestSerializableVariable);
      assertEquals(
          "This is some field", ((TestSerializableVariable) readSerializable).getSomeField());
      assertEquals(MediaType.APPLICATION_JAVA_OBJECT.getName(), getMediaType(client));
    } finally {
      // Clean adhoc-tasks even if test fails
      List<Task> tasks = taskService.createTaskQuery().list();
      for (Task task : tasks) {
        taskService.deleteTask(task.getId(), true);
      }
    }
  }
 @Override
 public Representation put(Representation entity) throws ResourceException {
   this.userId = UmlgURLDecoder.decode((String) getRequestAttributes().get("userId"));
   User c = UMLG.get().getEntity(this.userId);
   try {
     String entityText = entity.getText();
     c.fromJson(entityText);
     String lookupUri =
         UmlgURLDecoder.decode(getReference().getQueryAsForm(false).getFirstValue("lookupUri"));
     lookupUri = "riap://host" + lookupUri;
     int fakeIdIndex = lookupUri.indexOf("fake");
     if (fakeIdIndex != -1) {
       int indexOfForwardSlash = lookupUri.indexOf("/", fakeIdIndex);
       String fakeId = lookupUri.substring(fakeIdIndex, indexOfForwardSlash);
       Object id = UmlgTmpIdManager.INSTANCE.get(fakeId);
       lookupUri = lookupUri.replace(fakeId, UmlgURLDecoder.encode(id.toString()));
     }
     ClientResource cr = new ClientResource(lookupUri);
     Representation result = cr.get();
     return result;
   } catch (Exception e) {
     if (e instanceof RuntimeException) {
       throw (RuntimeException) e;
     }
     throw new RuntimeException(e);
   } finally {
     UmlgTmpIdManager.INSTANCE.remove();
     UMLG.get().rollback();
   }
 }
  /** Test getting a task variable. GET runtime/tasks/{taskId}/variables/{variableName}/data */
  public void testGetTaskVariableData() throws Exception {
    try {
      // Test variable behaviour on standalone tasks
      Task task = taskService.newTask();
      taskService.saveTask(task);
      taskService.setVariableLocal(
          task.getId(), "localTaskVariable", "This is a binary piece of text".getBytes());

      // Force content-type to TEXT_PLAIN to make sure this is ignored and application-octect-stream
      // is always returned
      ClientResource client =
          getAuthenticatedClient(
              RestUrls.createRelativeResourceUrl(
                  RestUrls.URL_TASK_VARIABLE_DATA, task.getId(), "localTaskVariable"));
      client.get(MediaType.TEXT_PLAIN);

      assertEquals(Status.SUCCESS_OK, client.getResponse().getStatus());
      String actualResponseBytesAsText = client.getResponse().getEntityAsText();
      assertEquals("This is a binary piece of text", actualResponseBytesAsText);
      assertEquals(MediaType.APPLICATION_OCTET_STREAM.getName(), getMediaType(client));
    } finally {
      // Clean adhoc-tasks even if test fails
      List<Task> tasks = taskService.createTaskQuery().list();
      for (Task task : tasks) {
        taskService.deleteTask(task.getId(), true);
      }
    }
  }
  @Test
  public void shouldGetWithSSL() throws ResourceException {

    // Given
    setSslConfiguration();
    final String uri = "URI";
    final Map<String, String> queryParameters = new HashMap<String, String>();
    final Map<String, String> headers = new HashMap<String, String>();
    final Context context = mock(Context.class);
    final ConcurrentHashMap<String, Object> requestAttributes =
        new ConcurrentHashMap<String, Object>();
    final JSONObject restResponse = mock(JSONObject.class);

    given(resource.getContext()).willReturn(context);
    given(context.getAttributes()).willReturn(requestAttributes);
    given(resource.get(JSONObject.class)).willReturn(restResponse);
    given(restResponse.toString()).willReturn("{}");

    // When
    final JsonValue response = restClient.get(uri, queryParameters, headers);

    // Then
    verify(resource, never()).addQueryParameter(anyString(), anyString());
    verify(requestHeaders, never()).set(anyString(), anyString());
    verify(resource).getContext();
    assertTrue(requestAttributes.containsKey("sslContextFactory"));
    assertEquals(response.size(), 0);
  }
  /**
   * Tests that we can GET a value from the system and verify that it is within acceptable range.
   *
   * @throws Exception if GET fails
   */
  @Test
  public void testGet() throws Exception {
    PhotovoltaicsData.modifySystemState();

    // Set up the GET client
    // String getUrl = "http://localhost:7001/photovoltaic/state";
    String getUrl = "http://localhost:7001/cgi-bin/egauge?tot";
    ClientResource getClient = new ClientResource(getUrl);

    // Get the XML representation.
    DomRepresentation domRep = new DomRepresentation(getClient.get());
    Document domDoc = domRep.getDocument();

    // Grabs tags from XML.
    NodeList meterList = domDoc.getElementsByTagName("meter");
    NodeList energyList = domDoc.getElementsByTagName("energy");
    NodeList powerList = domDoc.getElementsByTagName("power");

    // Grabs attributes from tags.
    String title = ((Element) meterList.item(1)).getAttribute("title");

    // Grabs value from tags.
    String energy = ((Element) energyList.item(1)).getTextContent();
    String power = ((Element) powerList.item(1)).getTextContent();

    // Check that we are returning the correct title.
    assertEquals("Checking that title is \"Solar\"", title, "Solar");

    // Check that the returned value is within a delta of our value.
    assertEquals(1500, Double.parseDouble(energy), 1750);
    assertEquals(700, Double.parseDouble(power), 700);
  }
  public void testRepresentationTemplate() throws Exception {
    // Create a temporary directory for the tests
    File testDir = new File(System.getProperty("java.io.tmpdir"), "VelocityTestCase");
    testDir.mkdir();

    // Create a temporary template file
    File testFile = File.createTempFile("test", ".vm", testDir);
    FileWriter fw = new FileWriter(testFile);
    fw.write("Value=$value");
    fw.close();

    Map<String, Object> map = new TreeMap<String, Object>();
    map.put("value", "myValue");

    // Representation approach
    Reference ref = LocalReference.createFileReference(testFile);
    ClientResource r = new ClientResource(ref);
    Representation templateFile = r.get();
    TemplateRepresentation tr = new TemplateRepresentation(templateFile, map, MediaType.TEXT_PLAIN);
    final String result = tr.getText();
    assertEquals("Value=myValue", result);

    // Clean-up
    BioUtils.delete(testFile);
    BioUtils.delete(testDir, true);
  }
  @Test
  public void testErrorSearchRdfWithoutAuthentication() throws Exception {
    // prepare:
    final InferredOWLOntologyID testArtifact =
        this.loadTestArtifact(
            TestConstants.TEST_ARTIFACT_20130206, MediaType.APPLICATION_RDF_TURTLE);

    final ClientResource searchClientResource =
        new ClientResource(this.getUrl(PoddWebConstants.PATH_SEARCH));

    // request without authentication
    try {
      searchClientResource.addQueryParameter(PoddWebConstants.KEY_SEARCHTERM, "Scan");
      searchClientResource.addQueryParameter(
          PoddWebConstants.KEY_ARTIFACT_IDENTIFIER, testArtifact.getOntologyIRI().toString());
      searchClientResource.addQueryParameter(
          PoddWebConstants.KEY_SEARCH_TYPES, "http://purl.org/podd/ns/poddScience#Platform");

      searchClientResource.get(MediaType.APPLICATION_RDF_XML);
      Assert.fail("Should have thrown a ResourceException");
    } catch (final ResourceException e) {
      Assert.assertEquals(Status.CLIENT_ERROR_UNAUTHORIZED, e.getStatus());
    } finally {
      this.releaseClient(searchClientResource);
    }
  }
  /** Test getting a task variable. GET runtime/tasks/{taskId}/variables/{variableName}/data */
  public void testGetTaskVariableDataForIllegalVariables() throws Exception {
    try {
      // Test variable behaviour on standalone tasks
      Task task = taskService.newTask();
      taskService.saveTask(task);
      taskService.setVariableLocal(
          task.getId(), "localTaskVariable", "this is a plain string variable");

      // Try getting data for non-binary variable
      ClientResource client =
          getAuthenticatedClient(
              RestUrls.createRelativeResourceUrl(
                  RestUrls.URL_TASK_VARIABLE_DATA, task.getId(), "localTaskVariable"));
      try {
        client.get();
        fail("Exception expected");
      } catch (ResourceException expected) {
        assertEquals(Status.CLIENT_ERROR_NOT_FOUND, expected.getStatus());
        assertEquals(
            "The variable does not have a binary data stream.",
            expected.getStatus().getDescription());
      }

      // Try getting data for unexisting property
      client =
          getAuthenticatedClient(
              RestUrls.createRelativeResourceUrl(
                  RestUrls.URL_TASK_VARIABLE_DATA, task.getId(), "unexistingVariable"));
      try {
        client.get();
        fail("Exception expected");
      } catch (ResourceException expected) {
        assertEquals(Status.CLIENT_ERROR_NOT_FOUND, expected.getStatus());
        assertEquals(
            "Task '" + task.getId() + "' doesn't have a variable with name: 'unexistingVariable'.",
            expected.getStatus().getDescription());
      }

    } finally {
      // Clean adhoc-tasks even if test fails
      List<Task> tasks = taskService.createTaskQuery().list();
      for (Task task : tasks) {
        taskService.deleteTask(task.getId(), true);
      }
    }
  }
 public void testGetUsers() throws Exception {
   ClientResource client = getAuthenticatedClient("users?searchText=erm");
   Representation response = client.get();
   JsonNode responseNode = objectMapper.readTree(response.getStream());
   assertNotNull(responseNode);
   assertEquals(1, responseNode.get("total").asInt());
   JsonNode userNode = responseNode.get("data").get(0);
   assertEquals("Kermit", userNode.get("firstName").asText());
 }
 public void testGetAllUsers() throws Exception {
   ClientResource client = getAuthenticatedClient("users");
   try {
     client.get();
     fail();
   } catch (Exception e) {
     // not allowed, should provide search text
   }
 }
Esempio n. 16
0
 public void doGet(String path) {
   ClientResource cr = new ClientResource(testContext, BASE_URI + path);
   try {
     cr.get();
   } catch (ResourceException e) {
     e.printStackTrace();
     Assert.fail();
   }
 }
  private int getRemainingCount() {
    final Reference reference = new Reference("http://localhost/clue/game.json");
    reference.setHostPort(port);

    final ClientResource resource = new ClientResource(reference);
    resource.setProtocol(Protocol.HTTP);
    resource.setChallengeResponse(getChallengeResponse());

    final ClueServerStatus response = resource.get(ClueServerStatus.class);
    resource.release();
    return response.getRemainingTriples().size();
  }
Esempio n. 18
0
  public FacebookPhoto getPhotos() {
    ClientResource cr = null;
    FacebookPhoto photos = null;

    try {
      cr = new ClientResource(uriPhoto + "&access_token=" + access_token);
      photos = cr.get(FacebookPhoto.class);
    } catch (ResourceException re) {
      System.err.println("Error when retrieving photos: " + cr.getResponse().getStatus());
      System.err.println(uri + "?access_token" + access_token);
    }

    return photos;
  }
Esempio n. 19
0
 public void doPut(String path, String fileToPut) {
   ClientResource cr = new ClientResource(testContext, BASE_URI + path);
   LocalReference ref = new LocalReference(fileToPut);
   ref.setProtocol(Protocol.CLAP);
   ClientResource local = new ClientResource(ref);
   Representation rep = local.get();
   if (fileToPut.endsWith(".csv")) rep.setMediaType(MediaType.TEXT_CSV);
   try {
     cr.put(rep);
   } catch (ResourceException e) {
     e.printStackTrace();
     Assert.fail();
   }
 }
  @Test
  public void testServerGetStatus() throws Exception {
    final Reference reference = new Reference("http://localhost/clue/game.xml");
    reference.setHostPort(port);

    final ClientResource resource = new ClientResource(reference);
    resource.setProtocol(Protocol.HTTP);
    resource.setChallengeResponse(getChallengeResponse());

    final ClueServerStatus response = resource.get(ClueServerStatus.class);
    resource.release();

    assertNotNull(response);
  }
Esempio n. 21
0
  @Test
  public void testGetCompute() {
    Compute compute = null;
    try {
      compute = new Compute(Architecture.x64, 2, "TestCase", 200, 20, State.active, null);
    } catch (NumberFormatException e) {
      e.printStackTrace();
    } catch (IllegalArgumentException e) {
      e.printStackTrace();
    } catch (URISyntaxException e) {
      e.printStackTrace();
    } catch (NamingException e) {
      e.printStackTrace();
    }
    // test if compute ist not null
    Assert.assertNotNull(compute);
    // connect to api
    clientResource.setReference(
        OcciConfig.getInstance().config.getString("occi.server.location")
            + "compute/"
            + compute.getId());
    clientResource.setHostRef(
        OcciConfig.getInstance().config.getString("occi.server.location")
            + "compute/"
            + compute.getId());
    // create new representation
    Representation representation = null;
    try {
      // send post request
      representation = clientResource.get();
    } catch (Exception ex) {
      System.out.println("Failed to execute GET request: " + ex.getMessage());
    }
    Assert.assertNotNull(representation);
    // get request and print it in debugger
    Request request = Request.getCurrent();
    System.out.println(request.toString() + "\n\n");
    System.out.println("--------------------------------");
    // get current response
    Response response = Response.getCurrent();
    Assert.assertNotNull(response);
    System.out.println("Response: " + response.toString());

    try {
      representation.write(System.out);
    } catch (IOException e) {
      System.out.println(e.getMessage());
    }
    System.out.println("\n--------------------------------");
  }
  @Test
  public void testRemainingTriples() {
    final Reference reference = new Reference("http://localhost/clue/triples/remaining.json");
    reference.setHostPort(port);

    final ClientResource resource = new ClientResource(reference);
    resource.setProtocol(Protocol.HTTP);
    resource.setChallengeResponse(getChallengeResponse());

    final TripleList response = resource.get(TripleList.class);
    resource.release();

    assertNotNull(response);
    assertEquals(324, response.size());
  }
  /** Assert if there are no Orders */
  protected void assertNoneOrder() {

    ClientResource cr = new ClientResource(getOrderUrl());
    ChallengeResponse chal = new ChallengeResponse(ChallengeScheme.HTTP_BASIC, userLogin, password);

    cr.setChallengeResponse(chal);

    Representation result = cr.get(getMediaTest());

    assertNotNull(result);
    assertTrue(cr.getStatus().isSuccess());

    Response response = getResponseOrderandUserstorage(getMediaTest(), result, Order.class, true);
    assertTrue(response.getSuccess());
    assertEquals(0, response.getTotal().intValue());
  }
  /**
   * Get the Order at the given url
   *
   * @param url the url where to find the Order
   * @return the Order found
   */
  protected Order getOrder(String url) {

    ClientResource cr = new ClientResource(url);

    ChallengeResponse chal = new ChallengeResponse(ChallengeScheme.HTTP_BASIC, userLogin, password);

    cr.setChallengeResponse(chal);

    Representation result = cr.get(getMediaTest());
    assertNotNull(result);
    assertTrue(cr.getStatus().isSuccess());
    Response response = getResponseOrderandUserstorage(getMediaTest(), result, Order.class);
    assertTrue(response.getSuccess());
    result.release();
    return (Order) response.getItem();
  }
Esempio n. 25
0
  public void doDelete(String path) {
    ClientResource cr = new ClientResource(testContext, BASE_URI + path);
    try {
      cr.delete();
    } catch (ResourceException e) {
      e.printStackTrace();
      Assert.fail();
    }

    try {
      cr.get();
      Assert.fail("resource still exists after delete");
    } catch (ResourceException e) {

    }
  }
Esempio n. 26
0
  public static void main(String[] args) {
    try {
      // Create the client resource
      ClientResource resource = new ClientResource("http://www.restlet.org");

      // Customize the referrer property
      resource.setReferrerRef("http://www.mysite.org");

      // Write the response entity on the console
      Representation tmp = resource.get(MediaType.TEXT_HTML);
      System.out.println(tmp.getMediaType());

      tmp.write(System.out);
    } catch (Exception e) {
      e.printStackTrace();
    }
  }
Esempio n. 27
0
  /**
   * Performs a test by sending HTTP Gets to the URL, and records the number of bytes returned. Each
   * test results are documented and displayed in standard out with the following information:
   *
   * <p>URL - The source URL of the test REQ CNT - How many times this test has run START - The
   * start time of the last test run STOP - The stop time of the last test run THREAD - The thread
   * id handling this test case RESULT - The result of the test. Either the number of bytes returned
   * or an error message.
   */
  private void doTest() {
    String result = "";
    this.reqCount++;

    // Connect and run test steps
    Date startTime = new Date();
    try {
      ClientResource client = new ClientResource(this.myURL);

      // place order
      JSONObject json = new JSONObject();
      json.put("payment", "quarter");
      json.put("action", "place-order");
      client.post(new JsonRepresentation(json), MediaType.APPLICATION_JSON);

      // Get Gumball Count
      Representation result_string = client.get();
      JSONObject json_count = new JSONObject(result_string.getText());
      result = Integer.toString((int) json_count.get("count"));
    } catch (Exception e) {
      result = e.toString();
    } finally {
      Date stopTime = new Date();
      // Print Report of Result:
      System.out.println(
          "======================================\n"
              + "URL     => "
              + this.myURL
              + "\n"
              + "REQ CNT => "
              + this.reqCount
              + "\n"
              + "START   => "
              + startTime
              + "\n"
              + "STOP    => "
              + stopTime
              + "\n"
              + "THREAD  => "
              + Thread.currentThread().getName()
              + "\n"
              + "RESULT  => "
              + result
              + "\n");
    }
  }
Esempio n. 28
0
  /**
   * The constructor is {@code private} to have strict control what instances exist at any time.
   * Instead of the constructor the {@code public} <i>static factory method</i> {@link
   * #getInstance(JavaClient)} returns the instances of the class.
   *
   * @param javaClient The corresponding {@code JavaClient}
   */
  private CoreServiceImpl(JavaClient javaClient) {
    super(CoreServiceID.INSTANCE, javaClient.getAPIBaseURL(), javaClient);

    this.javaClient = javaClient;

    restletClient = ((JavaClientImpl) javaClient).getRestletClient();

    ClientResource clientResource = new ClientResource(serviceURL.toExternalForm());
    clientResource.setNext(restletClient);
    CoreServiceInstanceDataResource coreServiceInstanceDataResource =
        clientResource.get(CoreServiceInstanceDataResource.class);

    System.out.println("[CoreService CoreServiceImpl] " + serviceURL.toExternalForm());

    maxEntityRequestSize = coreServiceInstanceDataResource.getParameters().getBatchLimit();
    paginationSize = coreServiceInstanceDataResource.getParameters().getPaginationSize();
  }
  public static void main(String[] args) throws ResourceException, IOException {

    if (args.length != 1) {
      System.err.println("Please specify name of file that includes the request.");
    } else {

      Properties properties = new Properties();
      properties.load(new FileInputStream(args[0]));

      ClientResource comparisonsResource = new ClientResource(properties.getProperty("endpoint"));
      try {
        comparisonsResource.get().write(System.out);
        System.out.println("\n");
      } catch (ResourceException e) {
        System.out.println(e);
      }
      try {
        // first comparison
        String firstComparisonId = UUID.randomUUID().toString();
        Comparison comparison =
            new Comparison(
                firstComparisonId,
                properties.getProperty("dataset1"),
                properties.getProperty("dataset2"),
                properties.getProperty("adapter"),
                properties.getProperty("extractor"),
                properties.getProperty("measure"));
        Representation post = comparisonsResource.post(getComparisonRepresentation(comparison));
        post.write(System.out);
        System.out.println("\n");

        try {
          Thread.sleep(1000);
        } catch (InterruptedException e) {
          // TODO Auto-generated catch block
          e.printStackTrace();
        }
      } catch (ResourceException e) {
        logger.log(Level.SEVERE, "Error connecting to server", e);
      }
    }
  }
  public static void main(String[] args) throws Exception {

    String uri = "http://*****:*****@aaa.com");
    emailList.add("*****@*****.**");
    emailList.add("*****@*****.**");
    emailList.add("*****@*****.**");
    emailList.add("*****@*****.**");
    emailList.add("*****@*****.**");
    emailList.add("*****@*****.**");
    emailList.add("*****@*****.**");
    emailList.add("*****@*****.**");
    emailList.add("*****@*****.**");
    emailList.add("*****@*****.**");
    account.setEmailList(emailList);

    String json = JSON.intoText(account);
    log.debug("account : {}", account);

    Representation entity = new StringRepresentation(json);
    entity.setMediaType(MediaType.APPLICATION_JSON);

    client.put(entity);

    //

    entity = client.get(MediaType.APPLICATION_JSON);

    json = entity.getText();

    account = JSON.fromText(json, Account.class);
    log.debug("account : {}", account);
  }