public Requisition getActiveRequisition(final boolean createIfMissing) { if (m_pending != null) { return m_pending; } final Requisition pending = RequisitionFileUtils.getLatestPendingOrSnapshotRequisition(getPendingForeignSourceRepository(), m_foreignSource); final Requisition deployed = getDeployedForeignSourceRepository().getRequisition(m_foreignSource); if (pending == null && deployed == null && createIfMissing) { return new Requisition(m_foreignSource); } else if (pending == null) { return deployed; } else if (deployed == null) { return pending; } else if (deployed.getDate().after(pending.getDate())) { // deployed is newer than pending return deployed; } return pending; }
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); } } }
@Override public void visitNode(final OnmsNodeRequisition nodeReq) { LOG.debug("Scheduling relate of node {}", nodeReq); currentPhase.add(parentSetter(m_provisionService, nodeReq, requisition.getForeignSource())); } };
/** * <p>Constructor for Requisition.</p> */ public Requisition() { updateNodeCache(); updateDateStamp(); }
@Override public void save(final Requisition requisition) throws ForeignSourceRepositoryException { LOG.debug("Queueing save of requisition {} (containing {} nodes)", requisition.getForeignSource(), requisition.getNodeCount()); validate(requisition); m_pendingRequisitions.put(requisition.getForeignSource(), requisition); m_executor.execute(new QueuePersistRunnable()); }
void addOrReplaceNode(final RequisitionNode node) { final Requisition req = getActiveRequisition(true); if (req != null) { req.updateDateStamp(); req.putNode(node); save(req); } }
@Test public void simpleSnapshotTest() throws URISyntaxException { Requisition pendingReq = new Requisition("test"); pendingReq.putNode(createNode("1")); m_pending.save(pendingReq); m_pending.flush(); pendingReq = m_pending.getRequisition(pendingReq.getForeignSource()); final File pendingSnapshot = RequisitionFileUtils.createSnapshot(m_pending, pendingReq.getForeignSource(), pendingReq.getDate()); m_repository.importResourceRequisition(new FileSystemResource(pendingSnapshot)); assertFalse(pendingSnapshot.exists()); final URL pendingUrl = m_pending.getRequisitionURL(pendingReq.getForeignSource()); final File pendingFile = new File(pendingUrl.toURI()); assertFalse(pendingFile.exists()); }
if (prevRequisition != null && prevRequisition.getNode(minion.getId()) != null) { prevRequisition.deleteNode(minion.getId()); prevRequisition.updateDateStamp(); nextRequisition = new Requisition(nextForeignSource); nextRequisition.updateDateStamp(); RequisitionNode requisitionNode = nextRequisition.getNode(minion.getId()); if (requisitionNode == null) { final RequisitionInterface requisitionInterface = new RequisitionInterface(); requisitionNode.putInterface(requisitionInterface); nextRequisition.putNode(requisitionNode); nextRequisition.setDate(new Date()); deployedForeignSourceRepository.save(nextRequisition); deployedForeignSourceRepository.flush(); nextRequisition.setDate(new Date()); deployedForeignSourceRepository.save(nextRequisition); deployedForeignSourceRepository.flush();
r = m_foreignSourceRepository.getRequisition(m_foreignSource); if (r == null) { r = new Requisition(m_foreignSource); r.updateDateStamp(); RequisitionNode rn = new RequisitionNode(); rn.setNodeLabel(node.getLabel()); rn.setLocation(locationName); r.putNode(rn); m_foreignSourceRepository.save(r); m_foreignSourceRepository.flush();
final Requisition req = new Requisition(); req.updateDateStamp(); req.updateLastImported(); req.setForeignSource("foreignSource1"); req.setNodes(nodes); req.validate(); } catch (final ValidationException e) { fail(); req.setNodes(nodes); req.validate(); } catch (final ValidationException e) { fail(); req.setNodes(nodes); req.validate(); fail(); } catch (final ValidationException e) { req.setNodes(nodes); req.validate(); fail(); } catch (final ValidationException e) {
if (newReq == null) { newReq = new Requisition(request.getForeignSource()); for (RequisitionNode newNode : newReq.getNodes()) { for (RequisitionNode curNode : curReq.getNodes()) { if (newNode.getForeignId().equals(curNode.getForeignId())) {
@Before public void createTestRepository() throws Exception { m_requisitionDirectory = Files.createTempDirectory("RequisitionFileUtilsTest"); if (m_requisitionDirectory.toFile().exists()) { FileUtils.deleteDirectory(m_requisitionDirectory.toFile()); } final FilesystemForeignSourceRepository fsr = new FilesystemForeignSourceRepository(); m_importDirectory = new File(m_requisitionDirectory.toFile(), "imports").getPath(); m_foreignSourceDirectory = new File(m_requisitionDirectory.toFile(), "foreign-sources").getPath(); fsr.setRequisitionPath(m_importDirectory); fsr.setForeignSourcePath(m_foreignSourceDirectory); fsr.afterPropertiesSet(); fsr.save(new Requisition("test")); m_repository = fsr; }
RequisitionNode getNode(final String foreignId) { flush(); final Requisition req = getActiveRequisition(false); return req == null ? null : req.getNode(foreignId); }
Requisition pendingReq = new Requisition("test"); pendingReq.putNode(createNode("1")); m_pending.save(pendingReq); m_pending.flush();
void addOrReplaceRequisition(final Requisition requisition) { if (requisition != null) { requisition.updateDateStamp(); save(requisition); } }
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; }
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); } }
protected void assertRequisitionsMatch(final String msg, final Requisition a, final Requisition b) { assertEquals(msg, a.getForeignSource(), b.getForeignSource()); assertEquals(msg, a.getNodes(), b.getNodes()); } }
final Requisition r = new Requisition(request.getForeignSource()); for (Record rec : records) { if (matchingRecord(request, rec)) { r.insertNode(createRequisitionNode(request, rec));
@Test public void testRequisitionWithSpace() { runTest( fsr -> { final Requisition req = new Requisition("foo bar"); req.setDate(new Date(0)); fsr.save(req); fsr.flush(); final Requisition saved = fsr.getRequisition("foo bar"); assertNotNull(saved); assertEquals(req, saved); }, null ); }