private CertificateAuthorityPortType getPort() {

    try {

      // //////////////////////////////////////////////////////
      // Search for CA organization
      // //////////////////////////////////////////////////////

      Organization caOrg = null;

      Collection<String> findQualifiers = new ArrayList<String>();
      findQualifiers.add(FindQualifier.SORT_BY_NAME_DESC);

      Collection<String> namePatterns = new ArrayList<String>();
      namePatterns.add("%" + organizationName + "%");

      // Make serch for organization name
      BulkResponse bulkResponse =
          businessQueryManager.findOrganizations(
              findQualifiers, namePatterns, null, null, null, null);
      Collection<Organization> searchedOrg = bulkResponse.getCollection();

      for (Organization org : searchedOrg) {
        if (org.getName().getValue().equals(organizationName)) {
          Logger.getLogger(this.getClass()).info("Organization - " + org.getName().getValue());
          caOrg = org;
          break;
        }
      }

      // //////////////////////////////////////////////////////
      // Search for CA Service
      // //////////////////////////////////////////////////////
      String url = null;
      if (caOrg != null) {

        Collection<Service> findServices = caOrg.getServices();
        for (Service service : findServices) {
          if (service.getName().getValue().equals("policia")) {
            Logger.getLogger(this.getClass())
                .info("    Service - " + service.getName().getValue().toString());
            // Get CA URL
            Collection<ServiceBinding> bindingList = service.getServiceBindings();
            for (ServiceBinding binding : bindingList) {
              url = binding.getAccessURI();
              System.out.println("URL: " + url);
            }
            break;
          }
        }

      } else {
        System.err.println("[LOG]Anacom organization was not found in jUDDI!");
      }

      CertificateAuthorityService ca = new CertificateAuthorityService(new URL(url));
      CertificateAuthorityPortType port = ca.getCertificateAuthorityPort();
      return port;

    } catch (Exception e) {
      System.err.println(
          "[jUDDI-ERROR] Error while getting replicas from jUDDI: " + e.getMessage());
      e.printStackTrace();
    }
    return null;
  }
  /**
   * Creates an organization, its classification, and its services, and saves it to the registry.
   */
  public String executePublish(String username, String password, String endpoint) {

    String id = null;
    RegistryService rs = null;
    BusinessLifeCycleManager blcm = null;
    BusinessQueryManager bqm = null;

    try {
      rs = connection.getRegistryService();
      blcm = rs.getBusinessLifeCycleManager();
      bqm = rs.getBusinessQueryManager();
      System.out.println("Got registry service, query " + "manager, and life cycle manager");

      // Get authorization from the registry
      PasswordAuthentication passwdAuth =
          new PasswordAuthentication(username, password.toCharArray());

      Set creds = new HashSet();
      creds.add(passwdAuth);
      connection.setCredentials(creds);
      System.out.println("Established security credentials");

      // Get hardcoded strings from a ResourceBundle
      ResourceBundle bundle = ResourceBundle.getBundle("com.sun.cb.CoffeeRegistry");

      // Create organization name and description
      Organization org = blcm.createOrganization(bundle.getString("org.name"));
      InternationalString s = blcm.createInternationalString(bundle.getString("org.description"));
      org.setDescription(s);

      // Create primary contact, set name
      User primaryContact = blcm.createUser();
      PersonName pName = blcm.createPersonName(bundle.getString("person.name"));
      primaryContact.setPersonName(pName);

      // Set primary contact phone number
      TelephoneNumber tNum = blcm.createTelephoneNumber();
      tNum.setNumber(bundle.getString("phone.number"));
      Collection phoneNums = new ArrayList();
      phoneNums.add(tNum);
      primaryContact.setTelephoneNumbers(phoneNums);

      // Set primary contact email address
      EmailAddress emailAddress = blcm.createEmailAddress(bundle.getString("email.address"));
      Collection emailAddresses = new ArrayList();
      emailAddresses.add(emailAddress);
      primaryContact.setEmailAddresses(emailAddresses);

      // Set primary contact for organization
      org.setPrimaryContact(primaryContact);

      // Set classification scheme to NAICS
      ClassificationScheme cScheme =
          bqm.findClassificationSchemeByName(null, bundle.getString("classification.scheme"));

      // Create and add classification
      Classification classification =
          (Classification)
              blcm.createClassification(
                  cScheme,
                  bundle.getString("classification.name"),
                  bundle.getString("classification.value"));
      Collection classifications = new ArrayList();
      classifications.add(classification);
      org.addClassifications(classifications);

      // Create services and service
      Collection services = new ArrayList();
      Service service = blcm.createService(bundle.getString("service.name"));
      InternationalString is =
          blcm.createInternationalString(bundle.getString("service.description"));
      service.setDescription(is);

      // Create service bindings
      Collection serviceBindings = new ArrayList();
      ServiceBinding binding = blcm.createServiceBinding();
      is = blcm.createInternationalString(bundle.getString("service.binding"));
      binding.setDescription(is);
      binding.setValidateURI(false);
      binding.setAccessURI(endpoint);
      serviceBindings.add(binding);

      // Add service bindings to service
      service.addServiceBindings(serviceBindings);

      // Add service to services, then add services to organization
      services.add(service);
      org.addServices(services);

      // Add organization and submit to registry
      // Retrieve key if successful
      Collection orgs = new ArrayList();
      orgs.add(org);
      BulkResponse response = blcm.saveOrganizations(orgs);
      Collection exceptions = response.getExceptions();
      if (exceptions == null) {
        System.out.println("Organization saved");

        Collection keys = response.getCollection();
        Iterator keyIter = keys.iterator();
        if (keyIter.hasNext()) {
          javax.xml.registry.infomodel.Key orgKey =
              (javax.xml.registry.infomodel.Key) keyIter.next();
          id = orgKey.getId();
          System.out.println("Organization key is " + id);
        }
      } else {
        Iterator excIter = exceptions.iterator();
        Exception exception = null;
        while (excIter.hasNext()) {
          exception = (Exception) excIter.next();
          System.err.println("Exception on save: " + exception.toString());
        }
      }
    } catch (Exception e) {
      e.printStackTrace();
      if (connection != null) {
        try {
          connection.close();
        } catch (JAXRException je) {
          System.err.println("Connection close failed");
        }
      }
    }
    return id;
  }
Exemplo n.º 3
0
  /**
   * Create and save an organization. Create and save a service. Request only service be returned.
   * Verify that only the service is returned.
   */
  public void testgetRegistryObjectsSpecifiedType() throws Exception {

    Key orgkey = null;
    String myServiceName = "TCK_TEST_SERVICE";
    Collection orgKeys = null;
    boolean pass = false;

    try {
      System.out.println("Create a service and an organization \n");
      Service service = lcm.createService(myServiceName);
      Collection myServices = new ArrayList();

      // create an organization
      Organization org = (Organization) lcm.createObject(lcm.ORGANIZATION);

      org.setName(lcm.createInternationalString("CTS_Test_ORG"));
      // publish the organization
      Collection orgs = new ArrayList();
      orgs.add(org);
      System.out.println("Save the organization and get the key id from getCollection\n");
      BulkResponse br = lcm.saveOrganizations(orgs); // publish to registry

      orgKeys = br.getCollection();
      Iterator iter = orgKeys.iterator();
      while (iter.hasNext()) {
        orgkey = (Key) iter.next();
      }
      String orgKeyId = orgkey.getId();
      System.out.println("Saved Organization key id is: " + orgKeyId + "\n");
      System.out.println("Call getRegistryObjects to get all owned objects\n");
      br = bqm.getRegistryObjects();
      System.out.println("Find the saved organization and add the service to it \n");
      // get the org back
      Collection ros = br.getCollection();
      Organization o = null;
      iter = ros.iterator();
      String regKeyId = null;
      while (iter.hasNext()) {
        Object obj = iter.next();
        if (obj instanceof Organization) {
          o = (Organization) obj;
          if (o.getKey().getId().equals(orgKeyId)) {
            System.out.println("Found the organization\n");
            regKeyId = o.getKey().getId();
            o.addService(service);
            myServices.add(service);
            break;
          }
        }
      }
      if (o == null) {
        System.out.println("Error: failed to get the Organization with getRegistryObjects \n");
      }
      // ==
      System.out.println("save the service to the registry \n");
      br = lcm.saveServices(myServices);
      Key servicekey = null;
      Collection serviceKeys = br.getCollection();
      System.out.println(
          "The number of service keys returned from getCollection is: "
              + serviceKeys.size()
              + "\n");
      iter = serviceKeys.iterator();
      while (iter.hasNext()) {
        servicekey = (Key) iter.next();
      }
      System.out.println("Save the service key returned from saveServices\n");
      String serviceKeyId = servicekey.getId();
      System.out.println("Saved Service key id is: " + serviceKeyId + "\n");
      System.out.println(
          "request service objects with getRegistryObjects(LifeCycleManager.SERVICE) \n");
      br = bqm.getRegistryObjects(LifeCycleManager.SERVICE);
      // br = bqm.getRegistryObjects();

      Collection myObjects = br.getCollection();
      System.out.println(
          "Count of objects returned from service request is: " + myObjects.size() + "\n");
      if (myObjects.size() == 0)
        System.out.println(" failed - nothing returned from getRegistryObjects");

      iter = myObjects.iterator();
      RegistryObject ro = null;

      while (iter.hasNext()) {
        ro = (RegistryObject) iter.next();
        if (ro instanceof Service) {
          System.out.println(" ro is a Service \n");
          if (ro.getKey().getId().equals(serviceKeyId)) {
            System.out.println("Got back my service - Good! \n");
            pass = true;
          }
        } else if (!(ro instanceof Service)) {
          System.out.println(" returned ro not a service! " + ro.toString() + "\n");
        }
      }

    } catch (Exception e) {
      System.out.println("Caught exception: " + e.getMessage());
      e.printStackTrace();
    } finally {
      System.out.println("cleanup at test end \n");
      // super.cleanUpRegistry(orgKeys, LifeCycleManager.ORGANIZATION);
    }

    assert (pass);
  }