SecureHelloUpload

As in the "Hello, World" example, the SecureHelloUpload client does three things

• Configure the DataUploader which is responsible for uploading observations to the server
• Define a tele observation with proper information on the patient, devices used, and of course measured values
• Perform the actual upload, testing that it went well

Configure the DataUploader

As both the upload and query application needs to configure the uploader, this is encapsulated in a global function.

  // Configure the architecture
  dataUploader = Shared.setupN4CConfiguration( serverAddress );

The difference between this example and "Hello, World" is that the uploader is configured to support secure connections through the address and port below:

  https://localhost:8443/observation

Define a tele observation

Please refer to the "Hello, World" example for more information on how to define a tele observation.

Perform the actual upload

  // Upload the observation to the server...
  FutureResult result = null;
  try {
      HttpConnector.trustKeystore(new FileInputStream("../../n4c_osgi/n4c_receiver/resources/keystore"));
      result = dataUploader.upload(sto, username, password);
      result.awaitUninterruptibly();
  } catch (GeneralSecurityException e) {
          e.printStackTrace();
  } catch (IOException e) {
      System.err.println("Currently unable to connect to server");
  }
  if ( result == null ) {
      System.out.println( "Upload returned a null result (was the server running?)." );
  } else {
      System.out.println( "Upload result: "+result.isSuccess() );
      System.out.println( "Upload connection result: "+result.result() );
  }

Since the upload is performed using an HTTPS connection, it is necessary for the server to use an SSL security certificate. Ideally, you should use a certificate issued by a trusted certification authority. However, and for testing purposes, self-signed certificates can also be used.

Please check "Configuring HTTPS" for information on how to create self-signed SSL certificates.

If you are using a self-signed certificate, you must tell the program that we will be trusting this particular certificate, even though it has not been signed by a trusted certificate authority. In this case, we will use a default self-signed keystore with certificates located in the file '(root)/n4c_osgi/n4c_receiver/resources/keystore'. The code for doing so, is

  HttpConnector.trustKeystore(new FileInputStream("../../n4c_osgi/n4c_receiver/resources/keystore"));

The basic upload is done using the upload(sto, username, password) method of the dataUploader, having the username and password defined as

  // Define username and password for authentication
  String username = "net4care";
  String password = "N3t4C@re";

where the username "net4care" is a default, already-existing user with administrator rights.

The method will return a FutureResult which can be queried for the result of the operation.

SecureHelloQuery

The SecureHelloQuery program does the following:

• Configures the DataUploader
• Defines a query for the last ten minutes of observations on the given person
• Sends the query to the server and
• Processes the returned observations

Configure the DataUploader

This step is identical to the one defined in the SecureHelloUpload program.

Define a query

The query is defined as in the HelloQuery program from the "Hello, World" example

Send the query

In order to send the query, we must specify the keystore that contains the certificate we want to use. This step is done the exact same way as in SecureHelloUpload. The actual query is sent using the query(query, username, password) method of the dataUploader instance we have defined earlier. Keep in mind that you have to include the username and password, which are defined as in SecureHelloUpload.

  // Send the query to the server. 
  QueryResult res = null; 
  try {
    HttpConnector.trustKeystore(new FileInputStream("../../n4c_osgi/n4c_receiver/resources/keystore"));
    res = dataUploader.query(query, username, password); 
    res.awaitUninterruptibly(); 
  } catch (IOException e) { 
    System.out.println("Currently unable to connect to server"); 
    e.printStackTrace(); 
    System.exit(-1); 
  } catch (Net4CareException e) { 
    System.out.println("Encountered a Net4Care exception \n" 
                       +"\n Please inspect the console for details"); 
    e.printStackTrace(); 
    System.exit(-1); 
  } catch (GeneralSecurityException e) {
    e.printStackTrace();
    System.exit(-1); 
  }

Process the returned observations

Please refer to HelloUpload from the "Hello, World" example