Example #1
0
          @Override
          public void handle(Request request, Response response) {

            String dbName = (String) request.getAttributes().get("dbname");
            String collection = (String) request.getAttributes().get("collection");

            if (request.getMethod() == Method.POST) {
              try {
                String query = request.getEntityAsText();
                System.out.println(query);
                TypeReference<Map<String, Object>> typeRef =
                    new TypeReference<Map<String, Object>>() {};
                Map<String, Object> map = null;
                try {
                  map = om.readValue(query, typeRef);
                } catch (Exception e) {
                  Logger.stderr(OBJECT_MAPPING_ERROR_MESSAGE + e);
                  return;
                }

                ObjectMapper om = new ObjectMapper();
                String r = null;
                try {
                  r = om.writeValueAsString(map);
                } catch (IOException e) {
                  e.printStackTrace();
                }

                storageInstance.insert(dbName, collection, (Map<String, Object>) map);
                response.setEntity(r, MediaType.APPLICATION_JSON);
              } catch (StorageException e) {
                Logger.stderr(INSERTING_ERROR_MESSAGE + e);
              }
            }
          }
  @Override
  protected int doHandle(Request request, Response response) {

    super.doHandle(request, response);

    if (response.getStatus().isSuccess() && request.getMethod().equals(Method.GET)) {
      boolean isHtml = false;
      for (Preference<MediaType> mt : request.getClientInfo().getAcceptedMediaTypes()) {
        if (mt.getMetadata().includes(MediaType.APPLICATION_XHTML)
            || mt.getMetadata().includes(MediaType.TEXT_HTML)) {
          isHtml = true;
          break;
        }
      }
      if (isHtml) {
        try {
          response.setEntity(toHtml(request, response));
        } catch (SlipStreamException e) {
          // ok it failed generating html... do we care?
        }
      }
    }

    return CONTINUE;
  }
Example #3
0
          @Override
          public void handle(Request request, Response response) {

            String dbName = (String) request.getAttributes().get("dbname");
            String collection = (String) request.getAttributes().get("collection");

            if (request.getMethod() == Method.POST) {
              try {
                String query = request.getEntityAsText();
                System.out.println(query);
                TypeReference<Map<String, Object>> typeRef =
                    new TypeReference<Map<String, Object>>() {};
                Map<String, Object> map = null;
                try {
                  map = om.readValue(query, typeRef);
                } catch (Exception e) {
                  Logger.stderr(OBJECT_MAPPING_ERROR_MESSAGE + e);
                  return;
                }
                storageInstance.dropIndex(dbName, collection, map);
                response.setEntity(query, MediaType.APPLICATION_JSON);
              } catch (StorageException e) {
                Logger.stderr(DROP_INDEX_ERROR_MESSAGE + e);
              }
            }
          }
  /**
   * Allows filtering before its handling by the target Restlet. By default it parses the template
   * variable, adjust the base reference, then extracts the attributes from form parameters (query,
   * cookies, entity) and finally tries to validate the variables as indicated by the {@link
   * #validate(String, boolean, String)} method.
   *
   * @param request The request to filter.
   * @param response The response to filter.
   * @return The {@link Filter#CONTINUE} status.
   */
  @Override
  protected int beforeHandle(Request request, Response response) {
    if (this.validations != null) {
      for (ValidateInfo validate : getValidations()) {
        if (validate.required && !request.getAttributes().containsKey(validate.attribute)) {
          response.setStatus(
              Status.CLIENT_ERROR_BAD_REQUEST,
              "Unable to find the \""
                  + validate.attribute
                  + "\" attribute in the request. Please check your request.");
        } else if (validate.format != null) {
          Object value = request.getAttributes().get(validate.attribute);

          if ((value != null) && !Pattern.matches(validate.format, value.toString())) {
            response.setStatus(
                Status.CLIENT_ERROR_BAD_REQUEST,
                "Unable to validate the value of the \""
                    + validate.attribute
                    + "\" attribute. The expected format is: "
                    + validate.format
                    + " (Java Regex). Please check your request.");
          }
        }
      }
    }

    return CONTINUE;
  }
 public String authenticate(Request request, Response response) {
   if (!request.getClientInfo().isAuthenticated()) {
     authenticator.challenge(response, false);
     return null;
   }
   return request.getClientInfo().getUser().getIdentifier();
 }
  /** Test Amazon S3 authentication. */
  public void testAwsS3() {
    HttpAwsS3Helper helper = new HttpAwsS3Helper();

    // Example Object GET
    ChallengeWriter cw = new ChallengeWriter();
    ChallengeResponse challenge =
        new ChallengeResponse(
            ChallengeScheme.HTTP_AWS_S3,
            "0PN5J17HBGZHT7JJ3X82",
            "uV3F3YluFJax1cknvbcGwgjvx4QpvB+leU8dUj2o");
    Request request = new Request(Method.GET, "http://johnsmith.s3.amazonaws.com/photos/puppy.jpg");
    Form httpHeaders = new Form();
    httpHeaders.add(HeaderConstants.HEADER_DATE, "Tue, 27 Mar 2007 19:36:42 +0000");

    helper.formatRawResponse(cw, challenge, request, httpHeaders);
    assertEquals("0PN5J17HBGZHT7JJ3X82:xXjDGYUmKxnwqr5KXNPGldn5LbA=", cw.toString());

    // Example Object PUT
    cw = new ChallengeWriter();
    request.setMethod(Method.PUT);
    httpHeaders.set(HeaderConstants.HEADER_DATE, "Tue, 27 Mar 2007 21:15:45 +0000", true);
    httpHeaders.add(HeaderConstants.HEADER_CONTENT_LENGTH, "94328");
    httpHeaders.add(HeaderConstants.HEADER_CONTENT_TYPE, "image/jpeg");
    helper.formatRawResponse(cw, challenge, request, httpHeaders);
    assertEquals("0PN5J17HBGZHT7JJ3X82:hcicpDDvL9SsO6AkvxqmIWkmOuQ=", cw.toString());
  }
Example #7
0
  @Override
  protected int beforeHandle(Request request, Response response) {
    if (Method.OPTIONS.equals(request.getMethod())) {
      Series<Header> requestHeaders =
          (Series<Header>) request.getAttributes().get(HeaderConstants.ATTRIBUTE_HEADERS);
      String origin = requestHeaders.getFirstValue("Origin", false, "*");
      String rh = requestHeaders.getFirstValue("Access-Control-Request-Headers", false, "*");
      Series<Header> responseHeaders =
          (Series<Header>) response.getAttributes().get(HeaderConstants.ATTRIBUTE_HEADERS);
      if (responseHeaders == null) {
        responseHeaders = new Series<Header>(Header.class);
      }
      responseHeaders.add("Access-Control-Allow-Origin", origin);
      responseHeaders.set("Access-Control-Expose-Headers", "Authorization, Link");
      responseHeaders.add("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,OPTIONS");
      responseHeaders.add("Access-Control-Allow-Headers", rh);
      responseHeaders.add("Access-Control-Allow-Credentials", "true");
      responseHeaders.add("Access-Control-Max-Age", "60");
      response.getAttributes().put(HeaderConstants.ATTRIBUTE_HEADERS, responseHeaders);
      response.setEntity(new EmptyRepresentation());
      return SKIP;
    }

    return super.beforeHandle(request, response);
  }
  /**
   * Tests partial Get requests.
   *
   * @throws IOException
   * @throws NoSuchAlgorithmException
   */
  @Test
  public void testGet() throws IOException, NoSuchAlgorithmException {
    Client client = new Client(Protocol.HTTP);

    // Test partial Get.
    Request request = new Request(Method.PUT, "http://localhost:" + TEST_PORT + "/");
    StringRepresentation rep = new StringRepresentation("0123456789");
    try {
      DigesterRepresentation digester = new DigesterRepresentation(rep);
      // Such representation computes the digest while
      // consuming the wrapped representation.
      digester.exhaust();
      // Set the digest with the computed one
      digester.setDigest(digester.computeDigest());
      request.setEntity(digester);

      Response response = client.handle(request);

      assertEquals(Status.SUCCESS_OK, response.getStatus());
      digester = new DigesterRepresentation(response.getEntity());
      digester.exhaust();
      assertTrue(digester.checkDigest());

      client.stop();
    } catch (Exception e) {
      fail(e.getMessage());
    }
  }
 /** Tests method getting/setting. */
 public void testMethod() throws Exception {
   final Request request = getRequest();
   request.setMethod(Method.GET);
   assertEquals(Method.GET, request.getMethod());
   request.setMethod(Method.POST);
   assertEquals(Method.POST, request.getMethod());
 }
  /**
   * @param args
   * @throws Exception
   */
  public static void main(String[] args) throws Exception {
    String propertyFilePath = args.length > 0 ? args[0] : "jeevlet.properties";

    // Get configuration
    int listenPort =
        Integer.parseInt(ConfigUtils.getProps(propertyFilePath).getProperty(Config.LISTEN_PORT));
    String hostDomain = ConfigUtils.getProps(propertyFilePath).getProperty(Config.HOST_DOMAIN);

    // Prepare the request
    String url = "http://" + hostDomain + ":" + listenPort + "/";
    Request request = new Request(Method.GET, url);
    request.setEntity(Config.STOP_GEONETWORK, MediaType.TEXT_PLAIN);

    // Handle it using an HTTP client connector
    Client client = new Client(Protocol.HTTP);

    try {
      client.start();
      Response response = client.handle(request);
    } catch (Exception e) {
      System.err.println("ERROR: Not running!");
      e.printStackTrace();
    } finally {
      client.stop();
      System.out.println("GeoNetwork shutdown ...");
      System.exit(0);
    }
  }
  @Before
  public void setUp() throws Exception {
    contactsRepository = ContactsRepository.getInstance();
    contactsRepository.setDbService(dbService);
    attributes = new ConcurrentHashMap<String, Object>();
    Subject subjectUnderTest = Mockito.mock(Subject.class);
    setSubject(subjectUnderTest);
    request = Mockito.mock(Request.class);
    Mockito.when(request.getClientInfo()).thenReturn(new ClientInfo());
    Mockito.when(request.getAttributes()).thenReturn(attributes);
    Reference targetRef = Mockito.mock(Reference.class);
    Reference resourceRef = Mockito.mock(Reference.class);
    Mockito.when(request.getResourceRef()).thenReturn(resourceRef);
    Mockito.when(resourceRef.getTargetRef()).thenReturn(targetRef);
    response = new Response(request);

    ValidatorService validatorService = Mockito.mock(ValidatorService.class);
    Validator validator = Mockito.mock(Validator.class);
    Mockito.when(validatorService.getValidator()).thenReturn(validator);
    Mockito.when(clipboardApplication.getValidatorService()).thenReturn(validatorService);

    RouteBuilder routeBuilder = Mockito.mock(RouteBuilder.class);
    Mockito.when(clipboardApplication.getRouteBuilders(Mockito.any()))
        .thenReturn(Arrays.asList(routeBuilder));
  }
Example #12
0
  /*
   * POST request to webServiceURL/version/devices/{deviceLibraryIdentifier}/registrations/{passTypeIdentifier}/{serialNumber}
   */
  @Post("json")
  public final void registerDeviceRequest(final Representation entity) {
    Request request = getRequest();
    Map<String, Object> requestAttributes = request.getAttributes();
    String deviceLibraryIdentifier = (String) requestAttributes.get("deviceLibraryIdentifier");
    String passTypeIdentifier = (String) requestAttributes.get("passTypeIdentifier");
    String serialNumber = (String) requestAttributes.get("serialNumber");
    String authString = request.getChallengeResponse().getRawValue();
    Status responseStatus;
    try {
      String jsonPushToken = entity.getText();
      PKPushToken pkPushToken = jsonObjectMapper.readValue(jsonPushToken, PKPushToken.class);

      LOGGER.debug("registerDeviceRequest - deviceLibraryIdentifier: {}", deviceLibraryIdentifier);
      LOGGER.debug("registerDeviceRequest - passTypeIdentifier: {}", passTypeIdentifier);
      LOGGER.debug("registerDeviceRequest - serialNumber: {}", serialNumber);
      LOGGER.debug("registerDeviceRequest - authString: {}", authString);
      LOGGER.debug("registerDeviceRequest - jsonPushToken: {}", jsonPushToken);
      LOGGER.debug("registerDeviceRequest - pkPushToken: {}", pkPushToken);
      responseStatus =
          handleRegisterDeviceRequest(
              deviceLibraryIdentifier, passTypeIdentifier, serialNumber, authString, pkPushToken);
    } catch (PKAuthTokenNotValidException e) {
      responseStatus = Status.CLIENT_ERROR_UNAUTHORIZED;
    } catch (IOException e) {
      responseStatus = Status.SERVER_ERROR_INTERNAL;
    }
    setStatusIntoResponse(responseStatus, getResponse());
  }
Example #13
0
  /*
   * DELETE request to webServiceURL/version/devices/{deviceLibraryIdentifier}/registrations/{passTypeIdentifier}/{serialNumber}
   */
  @Delete("json")
  public final void deleteDeviceRegistrationRequest(final Representation entity) {
    Request request = getRequest();
    Map<String, Object> requestAttributes = request.getAttributes();
    String deviceLibraryIdentifier = (String) requestAttributes.get("deviceLibraryIdentifier");
    String passTypeIdentifier = (String) requestAttributes.get("passTypeIdentifier");
    String serialNumber = (String) requestAttributes.get("serialNumber");
    ChallengeResponse authString = request.getChallengeResponse();

    LOGGER.debug(
        "deleteDeviceRegistrationRequest - deviceLibraryIdentifier: {}", deviceLibraryIdentifier);
    LOGGER.debug("deleteDeviceRegistrationRequest - passTypeIdentifier: {}", passTypeIdentifier);
    LOGGER.debug("deleteDeviceRegistrationRequest - serialNumber: {}", serialNumber);
    LOGGER.debug("deleteDeviceRegistrationRequest - authString: {}", authString);

    Status responseStatus;
    try {
      responseStatus =
          handleUnregisterDeviceRequest(
              deviceLibraryIdentifier, passTypeIdentifier, serialNumber, authString);
    } catch (PKAuthTokenNotValidException e) {
      responseStatus = Status.CLIENT_ERROR_UNAUTHORIZED;
    }
    setStatusIntoResponse(responseStatus, getResponse());
  }
  /**
   * Tests conditional ranges requests.
   *
   * @throws Exception
   */
  public void testConditionalRanges() throws Exception {
    Client client = new Client(Protocol.HTTP);

    // Test partial Get.
    Request request = new Request(Method.GET, "http://localhost:" + TEST_PORT + "/testGet");
    Response response = client.handle(request);
    Tag entityTag = response.getEntity().getTag();

    request.setRanges(Arrays.asList(new Range(1, Range.SIZE_MAX)));
    request.getConditions().setRangeTag(entityTag);
    response = client.handle(request);
    assertEquals(Status.SUCCESS_PARTIAL_CONTENT, response.getStatus());
    assertEquals("234567890", response.getEntity().getText());
    assertEquals(10, response.getEntity().getSize());
    assertEquals(9, response.getEntity().getAvailableSize());
    assertEquals(1, response.getEntity().getRange().getIndex());
    assertEquals(9, response.getEntity().getRange().getSize());

    entityTag = new Tag(entityTag.getName() + "-test");
    request.setRanges(Arrays.asList(new Range(1, Range.SIZE_MAX)));
    request.getConditions().setRangeTag(entityTag);
    response = client.handle(request);
    assertEquals(Status.SUCCESS_OK, response.getStatus());
    assertEquals("1234567890", response.getEntity().getText());
    client.stop();
  }
Example #15
0
  /**
   * Handles a call for a local entity. By default, only GET and HEAD methods are implemented.
   *
   * @param request The request to handle.
   * @param response The response to update.
   * @param decodedPath The URL decoded entity path.
   */
  @Override
  protected void handleLocal(Request request, Response response, String decodedPath) {
    int spi = decodedPath.indexOf("!/");
    String fileUri;
    String entryName;
    if (spi != -1) {
      fileUri = decodedPath.substring(0, spi);
      entryName = decodedPath.substring(spi + 2);
    } else {
      fileUri = decodedPath;
      entryName = "";
    }

    LocalReference fileRef = new LocalReference(fileUri);
    if (Protocol.FILE.equals(fileRef.getSchemeProtocol())) {
      final File file = fileRef.getFile();
      if (Method.GET.equals(request.getMethod()) || Method.HEAD.equals(request.getMethod())) {
        handleGet(request, response, file, entryName, getMetadataService());
      } else if (Method.PUT.equals(request.getMethod())) {
        handlePut(request, response, file, entryName);
      } else {
        response.setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
        response.getAllowedMethods().add(Method.GET);
        response.getAllowedMethods().add(Method.HEAD);
        response.getAllowedMethods().add(Method.PUT);
      }
    } else {
      response.setStatus(Status.SERVER_ERROR_NOT_IMPLEMENTED, "Only works on local files.");
    }
  }
Example #16
0
 /*
  * GET request to webServiceURL/version/devices/{deviceLibraryIdentifier}/registrations/{passTypeIdentifier}?passesUpdatedSince=tag
  */
 @Get("json")
 public final Representation getSerialNumbersForPasses(final Representation entity) {
   Request request = getRequest();
   Map<String, Object> requestAttributes = request.getAttributes();
   String deviceLibraryIdentifier = (String) requestAttributes.get("deviceLibraryIdentifier");
   String passTypeIdentifier = (String) requestAttributes.get("passTypeIdentifier");
   String passesUpdatedSince = (String) requestAttributes.get("passesUpdatedSince");
   LOGGER.debug(
       "getSerialNumbersForPasses - deviceLibraryIdentifier: {}", deviceLibraryIdentifier);
   LOGGER.debug("getSerialNumbersForPasses - passTypeIdentifier: {}", passTypeIdentifier);
   LOGGER.debug("getSerialNumbersForPasses - passesUpdatedSince: {}", passesUpdatedSince);
   PKSerialNumbersOfPassesForDeviceResponse serialNumbersOfPassesForDevice =
       getSerialNumberOfPassesForDevice(
           deviceLibraryIdentifier, passTypeIdentifier, passesUpdatedSince);
   if (serialNumbersOfPassesForDevice == null
       || serialNumbersOfPassesForDevice.getSerialNumbers() == null) {
     setStatusIntoResponse(Status.SUCCESS_NO_CONTENT, getResponse());
     return null;
   }
   String responseJSONString;
   try {
     responseJSONString = jsonObjectMapper.writeValueAsString(serialNumbersOfPassesForDevice);
     return new StringRepresentation(responseJSONString, MediaType.APPLICATION_JSON);
   } catch (Exception e) {
     LOGGER.error("Error when parsing response to JSON:", e);
   }
   setStatusIntoResponse(Status.SERVER_ERROR_INTERNAL, getResponse());
   return null;
 }
 public void testCookies() throws IOException {
   final Request request = createGetRequest("cookies/cookieName");
   request.getCookies().add(new Cookie("cookieName", "cookie-value"));
   final Response response = accessServer(request);
   assertEquals(Status.SUCCESS_OK, response.getStatus());
   assertEquals("cookieName=cookie-value", response.getEntity().getText());
 }
  @Override
  protected IQueryRetrieval<IStructureRecord> createQuery(
      Context context, Request request, Response response) throws ResourceException {
    Form form = getParams();
    setTemplate(createTemplate(form));
    setGroupProperties(context, request, response);
    STRUCTURE_RELATION relation = null;
    try {
      Object cmp = request.getAttributes().get(compositionType);
      relation = STRUCTURE_RELATION.valueOf(cmp.toString().toUpperCase());
    } catch (Exception x) {
    }

    Object key = request.getAttributes().get(SubstanceResource.idsubstance);
    if (key == null) return new ReadSubstanceRelation(relation, null);
    try {
      return new ReadSubstanceRelation(
          relation, new SubstanceRecord(Integer.parseInt(key.toString())));
    } catch (Exception x) {
      int len = key.toString().trim().length();
      if ((len > 40) && (len <= 45)) {
        return new ReadSubstanceRelation(relation, new SubstanceRecord(key.toString()));
      }
      throw new ResourceException(Status.CLIENT_ERROR_BAD_REQUEST);
    }
  }
  /**
   * Returns the list of identifiers for the mails in the inbox
   *
   * @return The list of identifiers.
   * @throws ResourceException
   */
  protected List<String> getMailIdentifiers() throws ResourceException {
    final List<String> result = new ArrayList<String>();

    // 1 - Get to mailbox content
    final Request request = new Request(Method.GET, getMailboxUri());
    if (getMailboxChallengeScheme() != null) {
      final ChallengeResponse challengeResponse =
          new ChallengeResponse(
              getMailboxChallengeScheme(), getMailboxLogin(), getMailboxPassword());
      request.setChallengeResponse(challengeResponse);
    }
    final Response response = getContext().getClientDispatcher().handle(request);

    if (!response.getStatus().isSuccess()) {
      throw new ResourceException(response.getStatus(), "Cannot get the mail iddentifiers.");
    }

    // 2 - Parse the list of mails
    if (response.isEntityAvailable()) {
      final DomRepresentation rep = new DomRepresentation(response.getEntity());
      for (final Node node : rep.getNodes("/emails/email/@href")) {
        final String href = node.getNodeValue();
        if (href.startsWith("/")) {
          result.add(href.substring(1));
        } else {
          result.add(href);
        }
      }
    }

    return result;
  }
  public Response deleteJson(Reference reference, Representation representation)
      throws IOException {
    Request deleteRequest = createJsonRequest(reference, representation);
    deleteRequest.setMethod(Method.DELETE);

    return sendRequest(deleteRequest);
  }
 /**
  * Creates an uniform call.
  *
  * @param jdbcURI The database's JDBC URI (ex: jdbc:mysql://[hostname]/[database]).
  * @param request The request to send (valid XML request).
  */
 public static Request create(String jdbcURI, Representation request) {
   Request result = new Request();
   result.getClientInfo().setAgent(Engine.VERSION_HEADER);
   result.setMethod(Method.POST);
   result.setResourceRef(jdbcURI);
   result.setEntity(request);
   return result;
 }
Example #22
0
  /**
   * Allows filtering before its handling by the target Restlet. Does nothing by default.
   *
   * @param request The request to filter.
   * @param response The response to filter.
   * @return The continuation status.
   */
  @Override
  public int beforeHandle(Request request, Response response) {
    // Check if encoding of the request entity is needed
    if (isEncodingRequest() && canEncode(request.getEntity())) {
      request.setEntity(encode(request.getClientInfo(), request.getEntity()));
    }

    return CONTINUE;
  }
  private Request createXmlRequest(Reference reference, Representation representation) {
    Request xmlRequest = createRequest(reference, representation);
    xmlRequest
        .getClientInfo()
        .getAcceptedMediaTypes()
        .add(new Preference<MediaType>(MediaType.APPLICATION_XML));

    return xmlRequest;
  }
  private Request createJsonRequest(Reference reference, Representation representation) {
    Request jsonRequest = createRequest(reference, representation);
    jsonRequest
        .getClientInfo()
        .getAcceptedMediaTypes()
        .add(new Preference<MediaType>(MediaType.APPLICATION_JSON));

    return jsonRequest;
  }
Example #25
0
  /**
   * Handles a GET call.
   *
   * @param request The request to answer.
   * @param response The response to update.
   * @param file The Zip archive file.
   * @param entryName The Zip archive entry name.
   * @param metadataService The metadata service.
   */
  protected void handleGet(
      Request request,
      Response response,
      File file,
      String entryName,
      final MetadataService metadataService) {

    if (!file.exists()) {
      response.setStatus(Status.CLIENT_ERROR_NOT_FOUND);
    } else {
      ZipFile zipFile;

      try {
        zipFile = new ZipFile(file);
      } catch (Exception e) {
        response.setStatus(Status.SERVER_ERROR_INTERNAL, e);
        return;
      }

      Entity entity = new ZipEntryEntity(zipFile, entryName, metadataService);
      if (!entity.exists()) {
        response.setStatus(Status.CLIENT_ERROR_NOT_FOUND);
      } else {
        final Representation output;

        if (entity.isDirectory()) {
          // Return the directory listing
          final Collection<Entity> children = entity.getChildren();
          final ReferenceList rl = new ReferenceList(children.size());
          String fileUri = LocalReference.createFileReference(file).toString();
          String scheme = request.getResourceRef().getScheme();
          String baseUri = scheme + ":" + fileUri + "!/";

          for (final Entity entry : children) {
            rl.add(baseUri + entry.getName());
          }

          output = rl.getTextRepresentation();

          try {
            zipFile.close();
          } catch (IOException e) {
            // Do something ???
          }
        } else {
          // Return the file content
          output = entity.getRepresentation(metadataService.getDefaultMediaType(), getTimeToLive());
          output.setLocationRef(request.getResourceRef());
          Entity.updateMetadata(entity.getName(), output, true, getMetadataService());
        }

        response.setStatus(Status.SUCCESS_OK);
        response.setEntity(output);
      }
    }
  }
 protected AccessToken getAuthorisationApiToken() throws ServerException {
   Request req = getRequest();
   ChallengeResponse challengeResponse = req.getChallengeResponse();
   try {
     return oauth2TokenStore.readAccessToken(
         requestFactory.create(req), challengeResponse.getRawValue());
   } catch (InvalidGrantException e) {
     throw new ServerException("Unable to verify client identity.");
   }
 }
  @Override
  protected void addHeaders(Series<Header> headers) {
    Request request = getMessage().getRequest();
    addGeneralHeaders(headers);
    addEntityHeaders(request.getEntity(), headers);

    // NOTE: This must stay at the end because the AWS challenge
    // scheme requires access to all HTTP headers
    addRequestHeaders(headers);
  }
Example #28
0
 public void handle(Request request, Response response) {
   if (request.getProtocol().equals(Protocol.HTTP)) {
     List<Protocol> protocols = Arrays.asList(Protocol.HTTP);
     String helperClass = HttpClientHelper.class.getName();
     Client client = new Client(null, protocols, helperClass);
     client.handle(request, response);
   } else {
     new Client(request.getProtocol()).handle(request, response);
   }
 };
 /** Tests resource reference getting/setting. */
 public void testResourceRef() throws Exception {
   final Request request = getRequest();
   String uri = "http://www.restlet.org/";
   Reference reference = getReference(uri);
   request.setResourceRef(uri);
   assertEquals(reference, request.getResourceRef());
   uri = "http://www.restlet.org/something";
   reference = getReference(uri);
   request.setResourceRef(reference);
   assertEquals(reference, request.getResourceRef());
 }
 @Override
 protected void writeStartLine() throws IOException {
   Request request = getMessage().getRequest();
   getLineBuilder().append(request.getMethod().getName());
   getLineBuilder().append(' ');
   getLineBuilder()
       .append(ReferenceUtils.format(request.getResourceRef(), getHelper().isProxying(), request));
   getLineBuilder().append(' ');
   getLineBuilder().append(getVersion(request));
   getLineBuilder().append("\r\n");
 }