Example #1
0
 @Override
 public Payload create() throws Exception {
   sftp = acquire(sftpConnection);
   return Payloads.newInputStreamPayload(
       new CloseFtpChannelOnCloseInputStream(
           sftp.getSFTPEngine().open(path).getInputStream(), sftp));
 }
  private void assertCodeMakes(
      String method,
      URI uri,
      int statusCode,
      String message,
      String contentType,
      String content,
      Class<? extends Exception> expected) {

    ElasticStackErrorHandler function =
        Guice.createInjector().getInstance(ElasticStackErrorHandler.class);

    HttpCommand command = createMock(HttpCommand.class);
    HttpRequest request = new HttpRequest(method, uri);
    HttpResponse response =
        new HttpResponse(
            statusCode, message, Payloads.newInputStreamPayload(Strings2.toInputStream(content)));
    response.getPayload().getContentMetadata().setContentType(contentType);

    expect(command.getCurrentRequest()).andReturn(request).atLeastOnce();
    command.setException(classEq(expected));

    replay(command);

    function.handleError(command, response);

    verify(command);
  }
  public void testApplyInputStreamDetails() throws UnknownHostException {
    InputStream is = getClass().getResourceAsStream("/metadata.json");

    ParseMetadataFromJsonResponse parser = i.getInstance(ParseMetadataFromJsonResponse.class);
    Map<String, String> response =
        parser.apply(new HttpResponse(200, "ok", Payloads.newInputStreamPayload(is)));
    assertEquals(response, ImmutableMap.of("MD5", "IGPBYI1uC6+AJJxC4r5YBA==", "test", "1"));
  }
  public void testApplyInputStreamDetails() throws UnknownHostException {
    InputStream is = getClass().getResourceAsStream("/test_list_backupschedule.json");

    UnwrapOnlyJsonValue<BackupSchedule> parser =
        i.getInstance(Key.get(new TypeLiteral<UnwrapOnlyJsonValue<BackupSchedule>>() {}));
    BackupSchedule response =
        parser.apply(new HttpResponse(200, "ok", Payloads.newInputStreamPayload(is)));
    assertEquals(
        new BackupSchedule(WeeklyBackup.THURSDAY, DailyBackup.H_0400_0600, true), response);
  }
  public void testPrivate() throws UnknownHostException {
    InputStream is =
        getClass().getResourceAsStream("/cloudservers/test_list_addresses_private.json");

    UnwrapOnlyJsonValue<List<String>> parser =
        i.getInstance(Key.get(new TypeLiteral<UnwrapOnlyJsonValue<List<String>>>() {}));
    List<String> response =
        parser.apply(new HttpResponse(200, "ok", Payloads.newInputStreamPayload(is)));

    assertEquals(response, ImmutableList.of("10.176.42.16"));
  }
  @Test
  public void testApplyInputStreamDetails() throws UnknownHostException {
    InputStream is = getClass().getResourceAsStream("/test_error_handler.json");

    ParseErrorFromJsonResponse parser = i.getInstance(ParseErrorFromJsonResponse.class);
    ErrorResponse response =
        Iterables.getOnlyElement(
            parser.apply(new HttpResponse(200, "ok", Payloads.newInputStreamPayload(is))));
    assert "No object found that matches your input criteria.".equals(response.getMessage());
    assert "IllegalArgumentException".equals(response.getErrorCode());
  }
Example #7
0
  public Payload get(String path) {
    checkNotNull(path, "path");

    ChannelSftp sftp = getSftp();
    try {
      return Payloads.newInputStreamPayload(
          new CloseFtpChannelOnCloseInputStream(sftp.get(path), sftp));
    } catch (SftpException e) {
      throw new SshException(
          String.format("%s@%s:%d: Error getting path: %s", username, host, port, path), e);
    }
  }
  public void testApplyInputStream() {
    InputStream is = getClass().getResourceAsStream("/test_list_servers.json");

    List<Server> expects =
        ImmutableList.of(new Server(1234, "sample-server"), new Server(5678, "sample-server2"));

    UnwrapOnlyJsonValue<List<Server>> parser =
        i.getInstance(Key.get(new TypeLiteral<UnwrapOnlyJsonValue<List<Server>>>() {}));
    List<Server> response =
        parser.apply(new HttpResponse(200, "ok", Payloads.newInputStreamPayload(is)));

    assertEquals(response, expects);
  }
  @Test
  public void testApplyInputStreamDetails() throws UnknownHostException {
    InputStream is = getClass().getResourceAsStream("/test_get_server_list.json");

    ParseServerListFromJsonResponse parser = i.getInstance(ParseServerListFromJsonResponse.class);
    SortedSet<Server> response =
        parser.apply(new HttpResponse(200, "ok", Payloads.newInputStreamPayload(is)));

    Option dc = new Option(1l, "US-West-1", "US West 1 Datacenter");
    Option centOs = new Option(13L, "CentOS 5.2 (32-bit)", "CentOS 5.2 (32-bit)");
    Option webServer = new Option(1L, "Web Server", "Web or Application Server");
    Server server =
        new Server(
            75245L,
            dc,
            false,
            "PowerServer",
            "server to test the api. created by Alex",
            ServerState.ON,
            webServer,
            new Option(1L, "512MB", "Server with 512MB RAM"),
            centOs,
            new Ip(
                1313079L,
                "204.51.240.178",
                "204.51.240.176/255.255.255.240",
                true,
                IpState.ASSIGNED,
                dc),
            new ServerImage(
                1946L,
                "GSI-f8979644-e646-4711-ad58-d98a5fa3612c",
                "BitNami Gallery 2.3.1-0",
                "http://bitnami.org/stack/gallery",
                centOs,
                null,
                ServerImageType.WEB_APPLICATION_SERVER,
                ServerImageState.AVAILABLE,
                0.0,
                "24732/GSI-f8979644-e646-4711-ad58-d98a5fa3612c.img",
                true,
                true,
                new Date(1261504577971L),
                new Date(1262649582180L),
                ImmutableSortedSet.of(
                    new BillingToken(38L, "CentOS 5.2 32bit", 0.0),
                    new BillingToken(56L, "BitNami: Gallery", 0.0)),
                new Customer(24732L, "BitRock")));
    assertEquals(Iterables.getOnlyElement(response), server);
  }
  public void testApplyInputStreamDetails() throws UnknownHostException {
    InputStream is = getClass().getResourceAsStream("/test_list_addresses.json");

    UnwrapOnlyJsonValue<Addresses> parser =
        i.getInstance(Key.get(new TypeLiteral<UnwrapOnlyJsonValue<Addresses>>() {}));
    Addresses response =
        parser.apply(new HttpResponse(200, "ok", Payloads.newInputStreamPayload(is)));
    List<String> publicAddresses = ImmutableList.of("67.23.10.132", "67.23.10.131");

    List<String> privateAddresses = ImmutableList.of("10.176.42.16");

    assertEquals(response.getPublicAddresses(), publicAddresses);
    assertEquals(response.getPrivateAddresses(), privateAddresses);
  }
  @Test
  void testClosesInputStream()
      throws InterruptedException, IOException, SecurityException, NoSuchMethodException {
    HttpCommand command = createCommand();

    HttpResponse response = new HttpResponse(400, null, null);

    InputStream inputStream =
        new InputStream() {
          boolean isOpen = true;

          @Override
          public void close() {
            this.isOpen = false;
          }

          int count = 1;

          @Override
          public int read() throws IOException {
            if (this.isOpen) return (count > -1) ? count-- : -1;
            else return -1;
          }

          @Override
          public int available() throws IOException {
            if (this.isOpen) return count;
            else return 0;
          }
        };
    response.setPayload(Payloads.newInputStreamPayload(inputStream));
    response.getPayload().getContentMetadata().setContentLength(1l);
    assertEquals(response.getPayload().getInput().available(), 1);
    assertEquals(response.getPayload().getInput().read(), 1);

    handler.shouldRetryRequest(command, response);

    assertEquals(response.getPayload().getInput().available(), 0);
    assertEquals(response.getPayload().getInput().read(), -1);
  }
  public void testApplyInputStreamDetails() throws UnknownHostException {
    InputStream is = getClass().getResourceAsStream("/test_list_servers_detail.json");

    UnwrapOnlyJsonValue<List<Server>> parser =
        i.getInstance(Key.get(new TypeLiteral<UnwrapOnlyJsonValue<List<Server>>>() {}));
    List<Server> response =
        parser.apply(new HttpResponse(200, "ok", Payloads.newInputStreamPayload(is)));

    assertEquals(response.get(0).getId(), 1234);
    assertEquals(response.get(0).getName(), "sample-server");
    assertEquals(response.get(0).getImageId(), new Integer(2));
    assertEquals(response.get(0).getFlavorId(), new Integer(1));
    assertEquals(response.get(0).getHostId(), "e4d909c290d0fb1ca068ffaddf22cbd0");
    assertEquals(response.get(0).getStatus(), ServerStatus.BUILD);
    assertEquals(response.get(0).getProgress(), new Integer(60));
    List<String> publicAddresses = Lists.newArrayList("67.23.10.132", "67.23.10.131");
    List<String> privateAddresses = Lists.newArrayList("10.176.42.16");
    Addresses addresses1 = new Addresses();
    addresses1.getPrivateAddresses().addAll(privateAddresses);
    addresses1.getPublicAddresses().addAll(publicAddresses);
    assertEquals(response.get(0).getAddresses(), addresses1);
    assertEquals(
        response.get(0).getMetadata(),
        ImmutableMap.of("Server Label", "Web Head 1", "Image Version", "2.1"));
    assertEquals(response.get(1).getId(), 5678);
    assertEquals(response.get(1).getName(), "sample-server2");
    assertEquals(response.get(1).getImageId(), new Integer(2));
    assertEquals(response.get(1).getFlavorId(), new Integer(1));
    assertEquals(response.get(1).getHostId(), "9e107d9d372bb6826bd81d3542a419d6");
    assertEquals(response.get(1).getStatus(), ServerStatus.ACTIVE);
    assertEquals(response.get(1).getProgress(), null);
    List<String> publicAddresses2 = Lists.newArrayList("67.23.10.133");
    List<String> privateAddresses2 = Lists.newArrayList("10.176.42.17");
    Addresses addresses2 = new Addresses();
    addresses2.getPrivateAddresses().addAll(privateAddresses2);
    addresses2.getPublicAddresses().addAll(publicAddresses2);
    assertEquals(response.get(1).getAddresses(), addresses2);
    assertEquals(response.get(1).getMetadata(), ImmutableMap.of("Server Label", "DB 1"));
  }
    public HttpResponse apply(Response nativeResponse) {

      InputStream in = null;
      try {
        in =
            BaseHttpCommandExecutorService.consumeOnClose(nativeResponse.getResponseBodyAsStream());
      } catch (IOException e) {
        Closeables.closeQuietly(in);
        propagate(e);
        assert false : "should have propagated exception";
      }

      Payload payload = in != null ? Payloads.newInputStreamPayload(in) : null;
      HttpResponse response =
          new HttpResponse(nativeResponse.getStatusCode(), nativeResponse.getStatusText(), payload);
      Multimap<String, String> headers = LinkedHashMultimap.create();
      for (Entry<String, List<String>> header : nativeResponse.getHeaders()) {
        headers.putAll(header.getKey(), header.getValue());
      }
      utils.setPayloadPropertiesFromHeaders(headers, response);
      return response;
    }
  private void assertCodeMakes(
      String method,
      URI uri,
      int statusCode,
      String message,
      String contentType,
      String content,
      Class<? extends Exception> expected) {

    ParseAzureBlobErrorFromXmlContent function =
        Guice.createInjector(
                new SaxParserModule(),
                new AbstractModule() {

                  @Override
                  protected void configure() {
                    bind(SharedKeyLiteAuthentication.class)
                        .toInstance(createMock(SharedKeyLiteAuthentication.class));
                  }
                })
            .getInstance(ParseAzureBlobErrorFromXmlContent.class);

    HttpCommand command = createMock(HttpCommand.class);
    HttpRequest request = new HttpRequest(method, uri);
    HttpResponse response =
        new HttpResponse(
            statusCode, message, Payloads.newInputStreamPayload(Strings2.toInputStream(content)));
    response.getPayload().getContentMetadata().setContentType(contentType);

    expect(command.getCurrentRequest()).andReturn(request).atLeastOnce();
    command.setException(classEq(expected));

    replay(command);

    function.handleError(command, response);

    verify(command);
  }