/**
* Updates information in BulkResponse in the case of asynchronous connection. If connection is
* asynchronous, the response should be sent with status = STATUS_UNAVAILABLE. The provider calls
* the update method to store the information, reset the status, and notify() the thread in case a
* client has called a method resulting in a wait() until the information is available.
*/
public void updateResponse(BulkResponse update) throws JAXRException {
synchronized (this) {
// set content and status
setPartialResponse(update.isPartialResponse());
collection = new ArrayList(update.getCollection());
if (update.getExceptions() != null) {
exceptions = new ArrayList(update.getExceptions());
}
setStatus(update.getStatus());
// wake up thread if waiting
this.notify();
}
}
public void testClassificationOnConcepts() throws Exception {
login();
getJAXREssentials();
Concept concept = null;
Collection concepts = new ArrayList(1);
String portTypeName = "Test Port Type";
concept = blm.createConcept(null, portTypeName, "");
ExternalLink wsdlLink =
blm.createExternalLink("http://test.org/" + portTypeName, "TEST Port Type definition");
concept.addExternalLink(wsdlLink);
ClassificationScheme TYPE =
(ClassificationScheme)
bqm.getRegistryObject(UUID_TYPE, LifeCycleManager.CLASSIFICATION_SCHEME);
assertTrue("Classifications are not empty", TYPE.getClassifications().size() > 0);
System.out.println("TYPE.Classifications = " + TYPE.getClassifications());
concept.addClassification(
blm.createClassification(
TYPE, blm.createInternationalString("TEST CLASSIFICATION"), "test portType"));
concepts.add(concept);
BulkResponse response = blm.saveConcepts(concepts);
if (response != null && response.getCollection().size() > 0) {
concept.setKey((Key) response.getCollection().iterator().next());
assertNotNull("Key created != null", concept.getKey());
System.out.println("Concept Key = " + concept.getKey() + "\".");
}
// Obtain the saved concepts
Concept savedConcept =
(Concept) bqm.getRegistryObject(concept.getKey().getId(), LifeCycleManager.CONCEPT);
assertNotNull("savedConcept is not null", savedConcept);
Collection collection = savedConcept.getClassifications();
assertNotNull("Classifications is not null", collection);
assertTrue("Classifications is not empty", collection.isEmpty() == false);
}
/**
* 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;
}
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;
}
/**
* 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);
}
