void updateInterface(
final String foreignId, final String ipAddress, final MultivaluedMapImpl params) {
final String foreignSource = m_foreignSource;
LOG.debug(
"updateInterface: Updating interface {} on node {}/{}",
ipAddress,
foreignSource,
foreignId);
if (params.isEmpty()) return;
final Requisition req = getActiveRequisition(false);
if (req != null) {
final RequisitionNode node = req.getNode(foreignId);
if (node != null) {
final RequisitionInterface iface = node.getInterface(ipAddress);
if (iface != null) {
req.updateDateStamp();
RestUtils.setBeanProperties(iface, params);
save(req);
LOG.debug(
"updateInterface: Interface {} on node {}/{} updated",
ipAddress,
foreignSource,
foreignId);
}
}
}
}
RequisitionInterface getInterfaceForNode(final String foreignId, final String ipAddress) {
flush();
final Requisition req = getActiveRequisition(false);
final RequisitionNode node = req == null ? null : req.getNode(foreignId);
return node == null ? null : node.getInterface(ipAddress);
}
RequisitionAssetCollection getAssetParameters(final String foreignId) {
flush();
final Requisition req = getActiveRequisition(false);
final RequisitionNode node = req == null ? null : req.getNode(foreignId);
return node == null ? null : new RequisitionAssetCollection(node.getAssets());
}
RequisitionAsset getAssetParameter(final String foreignId, final String parameter) {
flush();
final Requisition req = getActiveRequisition(false);
final RequisitionNode node = req == null ? null : req.getNode(foreignId);
return node == null ? null : node.getAsset(parameter);
}
RequisitionCategory getCategory(final String foreignId, final String category) {
flush();
final Requisition req = getActiveRequisition(false);
final RequisitionNode node = req == null ? null : req.getNode(foreignId);
return node == null ? null : node.getCategory(category);
}
RequisitionCategoryCollection getCategories(final String foreignId) {
flush();
final Requisition req = getActiveRequisition(false);
final RequisitionNode node = req == null ? null : req.getNode(foreignId);
return node == null ? null : new RequisitionCategoryCollection(node.getCategories());
}
RequisitionInterfaceCollection getInterfacesForNode(final String foreignId) {
flush();
final Requisition req = getActiveRequisition(false);
final RequisitionNode node = req == null ? null : req.getNode(foreignId);
return node == null ? null : new RequisitionInterfaceCollection(node.getInterfaces());
}
protected URL createSnapshot(final String foreignSource) throws MalformedURLException {
System.err.println("--- creating snapshot for " + foreignSource + " ---");
Requisition pending = m_pending.getRequisition(foreignSource);
Requisition deployed = m_active.getRequisition(foreignSource);
final Date deployedDate = deployed == null ? null : deployed.getDate();
final Date pendingDate = pending == null ? null : pending.getDate();
if (deployedDate == null)
return RequisitionFileUtils.createSnapshot(m_pending, foreignSource, pending.getDate())
.toURI()
.toURL();
if (pendingDate == null) return m_active.getRequisitionURL(foreignSource);
final URL url;
if (deployedDate.before(pendingDate)) {
url =
RequisitionFileUtils.createSnapshot(m_pending, foreignSource, pendingDate)
.toURI()
.toURL();
} else {
url = m_active.getRequisitionURL(foreignSource);
}
System.err.println("deployedDate = " + deployedDate);
System.err.println("pendingDate = " + pendingDate);
System.err.println("url = " + url);
return url;
}
void addOrReplaceNode(final RequisitionNode node) {
final Requisition req = getActiveRequisition(true);
if (req != null) {
req.updateDateStamp();
req.putNode(node);
save(req);
}
}
@Test
public void testRequisition() throws Exception {
createRequisition();
Requisition r = m_foreignSourceRepository.getRequisition(m_defaultForeignSourceName);
TestVisitor v = new TestVisitor();
r.visit(v);
assertEquals("number of nodes visited", 2, v.getNodeReqs().size());
assertEquals("node name matches", "apknd", v.getNodeReqs().get(0).getNodeLabel());
}
void deleteNode(final String foreignId) {
LOG.debug(
"deleteNode: Deleting node {} from foreign source {}", foreignId, getForeignSource());
final Requisition req = getActiveRequisition(false);
if (req != null) {
req.updateDateStamp();
req.deleteNode(foreignId);
save(req);
}
}
RequisitionMonitoredService getServiceForInterface(
final String foreignId, final String ipAddress, final String service) {
flush();
final Requisition req = getActiveRequisition(false);
final RequisitionNode node = req == null ? null : req.getNode(foreignId);
final RequisitionInterface iface = node == null ? null : node.getInterface(ipAddress);
return iface == null ? null : iface.getMonitoredService(service);
}
void addOrReplaceInterface(final String foreignId, final RequisitionInterface iface) {
final Requisition req = getActiveRequisition(true);
if (req != null) {
final RequisitionNode node = req.getNode(foreignId);
if (node != null) {
req.updateDateStamp();
node.putInterface(iface);
save(req);
}
}
}
void addOrReplaceNodeCategory(final String foreignId, final RequisitionCategory category) {
final Requisition req = getActiveRequisition(true);
if (req != null) {
final RequisitionNode node = req.getNode(foreignId);
if (node != null) {
req.updateDateStamp();
node.putCategory(category);
save(req);
}
}
}
void addOrReplaceNodeAssetParameter(final String foreignId, final RequisitionAsset asset) {
final Requisition req = getActiveRequisition(true);
if (req != null) {
final RequisitionNode node = req.getNode(foreignId);
if (node != null) {
req.updateDateStamp();
node.putAsset(asset);
save(req);
}
}
}
/** {@inheritDoc} */
@Override
public synchronized Requisition importResourceRequisition(final Resource resource)
throws ForeignSourceRepositoryException {
final Requisition requisition =
m_deployedForeignSourceRepository.importResourceRequisition(resource);
final String foreignSource = requisition.getForeignSource();
cleanUpDeployedForeignSources(foreignSource);
cleanUpSnapshots(requisition);
return requisition;
}
void updateRequisition(final MultivaluedMapImpl params) {
final String foreignSource = m_foreignSource;
LOG.debug("updateRequisition: Updating requisition with foreign source {}", foreignSource);
if (params.isEmpty()) return;
final Requisition req = getActiveRequisition(false);
if (req != null) {
req.updateDateStamp();
RestUtils.setBeanProperties(req, params);
save(req);
LOG.debug("updateRequisition: Requisition with foreign source {} updated", foreignSource);
}
}
/** {@inheritDoc} */
@Override
public Requisition createProvisioningGroup(final String name) {
m_writeLock.lock();
try {
final Requisition group = new Requisition();
group.setForeignSource(name);
m_pendingForeignSourceRepository.save(group);
m_pendingForeignSourceRepository.flush();
return m_pendingForeignSourceRepository.getRequisition(name);
} finally {
m_writeLock.unlock();
}
}
void addOrReplaceService(
final String foreignId, final String ipAddress, final RequisitionMonitoredService service) {
final Requisition req = getActiveRequisition(true);
if (req != null) {
final RequisitionNode node = req.getNode(foreignId);
if (node != null) {
final RequisitionInterface iface = node.getInterface(ipAddress);
if (iface != null) {
req.updateDateStamp();
iface.putMonitoredService(service);
save(req);
}
}
}
}
@Test
public void integrationTest() {
/*
* First, the user creates a requisition in the UI, or RESTful
* interface.
*/
Requisition pendingReq = new Requisition("test");
pendingReq.putNode(createNode("1"));
m_pending.save(pendingReq);
m_pending.flush();
/*
* Then, the user makes a foreign source configuration to go along
* with that requisition.
*/
ForeignSource pendingSource = m_repository.getForeignSource("test");
assertTrue(pendingSource.isDefault());
pendingSource.setDetectors(new ArrayList<PluginConfig>());
m_pending.save(pendingSource);
m_pending.flush();
/*
* Now we got an import event, so we import that requisition file,
* and save it. The ForeignSource in the pending repository should
* match the one in the active one, now.
*/
Requisition activeReq =
m_repository.importResourceRequisition(
new UrlResource(m_pending.getRequisitionURL("test")));
ForeignSource activeSource = m_active.getForeignSource("test");
// and the foreign source should be the same as the one we made earlier, only this time it's
// active
assertEquals(activeSource.getName(), pendingSource.getName());
assertEquals(activeSource.getDetectorNames(), pendingSource.getDetectorNames());
assertEquals(activeSource.getScanInterval(), pendingSource.getScanInterval());
assertRequisitionsMatch("active and pending requisitions should match", activeReq, pendingReq);
/*
* Since it's been officially deployed, the requisition and foreign
* source should no longer be in the pending repo.
*/
assertNull(
"the requisition should be null in the pending repo", m_pending.getRequisition("test"));
assertTrue(
"the foreign source should be default since there's no specific in the pending repo",
m_pending.getForeignSource("test").isDefault());
}
void deleteAssetParameter(final String foreignId, final String parameter) {
LOG.debug(
"deleteAssetParameter: Deleting asset parameter {} from node {}/{}",
parameter,
getForeignSource(),
foreignId);
final Requisition req = getActiveRequisition(false);
if (req != null) {
final RequisitionNode node = req.getNode(foreignId);
if (node != null) {
req.updateDateStamp();
node.deleteAsset(parameter);
save(req);
}
}
}
void deleteInterface(final String foreignId, final String ipAddress) {
LOG.debug(
"deleteInterface: Deleting interface {} from node {}/{}",
ipAddress,
getForeignSource(),
foreignId);
final Requisition req = getActiveRequisition(false);
if (req != null) {
final RequisitionNode node = req.getNode(foreignId);
if (node != null) {
req.updateDateStamp();
node.deleteInterface(ipAddress);
save(req);
}
}
}
void deleteCategory(final String foreignId, final String category) {
LOG.debug(
"deleteCategory: Deleting category {} from node {}/{}",
category,
getForeignSource(),
foreignId);
final Requisition req = getActiveRequisition(false);
if (req != null) {
final RequisitionNode node = req.getNode(foreignId);
if (node != null) {
req.updateDateStamp();
node.deleteCategory(category);
save(req);
}
}
}
private void cleanUpSnapshots(final Requisition requisition) {
final String foreignSource = requisition.getForeignSource();
final Date pendingDate = m_pendingForeignSourceRepository.getRequisitionDate(foreignSource);
final List<File> pendingSnapshots =
RequisitionFileUtils.findSnapshots(m_pendingForeignSourceRepository, foreignSource);
if (pendingDate != null) {
/* determine whether to delete the pending requisition */
boolean deletePendingRequisition = true;
if (pendingSnapshots.size() > 0) {
for (final File pendingSnapshotFile : pendingSnapshots) {
if (isNewer(pendingSnapshotFile, pendingDate)) {
// the pending file is newer than an in-process snapshot, don't delete it
deletePendingRequisition = false;
break;
}
}
}
if (deletePendingRequisition) {
m_pendingForeignSourceRepository.delete(requisition);
}
}
/* determine whether this requisition was imported from a snapshot, and if so, delete its snapshot file */
RequisitionFileUtils.deleteResourceIfSnapshot(requisition);
final Date deployedDate = m_deployedForeignSourceRepository.getRequisitionDate(foreignSource);
if (deployedDate != null) {
RequisitionFileUtils.deleteSnapshotsOlderThan(
getPendingForeignSourceRepository(), foreignSource, deployedDate);
}
}
protected String getSummaryForRequisition(final File file) {
final Requisition requisition =
JaxbUtils.unmarshal(Requisition.class, new FileSystemResource(file));
final StringBuilder sb = new StringBuilder();
if (requisition.getNodeCount() > 0) {
sb.append("(");
final Iterator<RequisitionNode> nodeIterator = requisition.getNodes().iterator();
while (nodeIterator.hasNext()) {
sb.append(nodeIterator.next().getNodeLabel());
if (nodeIterator.hasNext()) sb.append(", ");
}
sb.append(")");
}
final String requisitionSummary =
file.getPath() + sb.toString() + ": " + requisition.getDate().getTime();
return requisitionSummary;
}
@Test
public void multipleSnapshotTest() throws URISyntaxException, InterruptedException {
Requisition pendingReq = new Requisition("test");
pendingReq.putNode(createNode("1"));
m_pending.save(pendingReq);
m_pending.flush();
final String foreignSource = pendingReq.getForeignSource();
pendingReq = m_pending.getRequisition(foreignSource);
final File pendingSnapshotA =
RequisitionFileUtils.createSnapshot(m_pending, foreignSource, pendingReq.getDate());
// Now, start a new pending update after the original snapshot is "in progress"
pendingReq.updateDateStamp();
m_pending.save(pendingReq);
m_pending.flush();
final File pendingSnapshotB =
RequisitionFileUtils.createSnapshot(m_pending, foreignSource, pendingReq.getDate());
// "import" the A snapshot
m_repository.importResourceRequisition(new FileSystemResource(pendingSnapshotA));
assertFalse(pendingSnapshotA.exists());
assertTrue(pendingSnapshotB.exists());
// since there's still a newer snapshot in-progress, it is safe to delete the pending test.xml
URL pendingUrl = m_pending.getRequisitionURL(foreignSource);
assertNotNull(pendingUrl);
assertFalse(new File(pendingUrl.toURI()).exists());
// then, "import" the B snapshot
final Requisition bReq =
m_repository.importResourceRequisition(new FileSystemResource(pendingSnapshotB));
assertFalse(pendingSnapshotA.exists());
assertFalse(pendingSnapshotB.exists());
// now the pending test.xml should be gone
pendingUrl = m_pending.getRequisitionURL(foreignSource);
assertNotNull(pendingUrl);
assertFalse(new File(pendingUrl.toURI()).exists());
// the last (B) pending import should match the deployed
final Requisition deployedRequisition = m_active.getRequisition(foreignSource);
assertEquals(deployedRequisition.getDate().getTime(), bReq.getDate().getTime());
}
/**
* getProvisioningGroupNames
*
* @return a {@link java.util.Collection} object.
*/
@Override
public Collection<String> getProvisioningGroupNames() {
m_readLock.lock();
try {
m_deployedForeignSourceRepository.flush();
final Set<String> names = new TreeSet<String>();
for (final Requisition r : m_deployedForeignSourceRepository.getRequisitions()) {
names.add(r.getForeignSource());
}
m_pendingForeignSourceRepository.flush();
for (final Requisition r : m_pendingForeignSourceRepository.getRequisitions()) {
names.add(r.getForeignSource());
}
return names;
} finally {
m_readLock.unlock();
}
}
/** {@inheritDoc} */
@Override
public Requisition addNewNodeToGroup(final String groupName, final String nodeLabel) {
m_writeLock.lock();
try {
final Requisition group = getProvisioningGroup(groupName);
final RequisitionNode node =
createNode(nodeLabel, String.valueOf(System.currentTimeMillis()));
node.setBuilding(groupName);
group.insertNode(node);
m_pendingForeignSourceRepository.save(group);
m_pendingForeignSourceRepository.flush();
return m_pendingForeignSourceRepository.getRequisition(groupName);
} finally {
m_writeLock.unlock();
}
}
URL createSnapshot() throws MalformedURLException {
flush();
final Requisition pending =
getPendingForeignSourceRepository().getRequisition(getForeignSource());
final Requisition deployed =
getDeployedForeignSourceRepository().getRequisition(getForeignSource());
final URL activeUrl =
pending == null
|| (deployed != null
&& deployed.getDateStamp().compare(pending.getDateStamp()) > -1)
? getDeployedForeignSourceRepository().getRequisitionURL(getForeignSource())
: RequisitionFileUtils.createSnapshot(
getPendingForeignSourceRepository(), getForeignSource(), pending.getDate())
.toURI()
.toURL();
return activeUrl;
}
void deleteInterfaceService(
final String foreignId, final String ipAddress, final String service) {
LOG.debug(
"deleteInterfaceService: Deleting service {} from interface {} on node {}/{}",
service,
ipAddress,
getForeignSource(),
foreignId);
final Requisition req = getActiveRequisition(false);
if (req != null) {
final RequisitionNode node = req.getNode(foreignId);
if (node != null) {
final RequisitionInterface iface = node.getInterface(ipAddress);
if (iface != null) {
req.updateDateStamp();
iface.deleteMonitoredService(service);
save(req);
}
}
}
}