Examples of org.rhq.core.domain.measurement.Availability

org.rhq.core.domain.measurement.Availability
This Entity Bean stores information about resource availability. The actual data is run-length encoded. This means that the {@link #getAvailabilityType() availability state} (e.g. UP or DOWN) changed at the{@link #getStartTime() start time}. This provides historical data regarding when a resource was up or down. To get the current availability of a resource, it is best to use the {@link ResourceAvailability} entity instead. @see ResourceAvailability @author Heiko W. Rupp @author John Mazzitelli


        try {
            setupResource(); // inserts initial UNKNOWN Availability at epoch
            commitAndClose();


            Availability avail;
            long now = System.currentTimeMillis();


            // add a report that says the resource is down
            avail = new Availability(theResource, DOWN);
            AvailabilityReport report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);
            availabilityManager.mergeAvailabilityReport(report);


            // now pretend the agent sent us a report from a previous time period - should insert this in the past
            avail = new Availability(theResource, (now - 600000), UP);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);
            availabilityManager.mergeAvailabilityReport(report);
            assert getPointInTime(new Date(avail.getStartTime() - 2)) == UNKNOWN;
            assert getPointInTime(new Date(avail.getStartTime())) == UP;
            assert getPointInTime(new Date(avail.getStartTime() + 2)) == UP;


            // it's still down though - since we've received a more recent report saying it was down
            assert availabilityManager.getCurrentAvailabilityTypeForResource(overlord, theResource.getId()) == DOWN;


            // now pretend the agent sent us reports from inbetween our existing time periods
            // this UP record combines with the UP we added previously
            avail = new Availability(theResource, (now - 300000), UP);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);
            availabilityManager.mergeAvailabilityReport(report);
            assert getPointInTime(new Date(avail.getStartTime() - 2)) == UP;
            assert getPointInTime(new Date(avail.getStartTime())) == UP;
            assert getPointInTime(new Date(avail.getStartTime() + 2)) == UP;


            // its still down though - since we've received a more recent report saying it was down
            assert availabilityManager.getCurrentAvailabilityTypeForResource(overlord, theResource.getId()) == DOWN;


            // this DOWN record combines with the current DOWN
            avail = new Availability(theResource, (now - 100000), DOWN);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);
            availabilityManager.mergeAvailabilityReport(report);
            assert getPointInTime(new Date(avail.getStartTime() - 2)) == UP;
            assert getPointInTime(new Date(avail.getStartTime())) == DOWN;
            assert getPointInTime(new Date(avail.getStartTime() + 2)) == DOWN;


            // this DOWN record is between the two UPs we added earlier. However, because we are RLE,
            // we actually lost the information that we had an UP at both -60000 and -30000.  We just
            // have a RLE interval of UP starting at -60000.  This new DOWN record will add a new row
            // that will indicate we were only UP from -60000 to -45000 and DOWN thereafter.  This is
            // an odd test and probably will never occur in the wild (why would an agent tell us
            // we were one status in the past but another status further back in the past?)
            avail = new Availability(theResource, (now - 450000), DOWN);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);
            availabilityManager.mergeAvailabilityReport(report);
            assert getPointInTime(new Date(avail.getStartTime() - 2)) == UP;
            assert getPointInTime(new Date(avail.getStartTime())) == DOWN;
            assert getPointInTime(new Date(avail.getStartTime() + 2)) == DOWN;


            // its still down
            assert availabilityManager.getCurrentAvailabilityTypeForResource(overlord, theResource.getId()) == DOWN;


            // let's insert one in the very beginning that is the same type as the current first interval
            avail = new Availability(theResource, (now - 700000), UP);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);
            availabilityManager.mergeAvailabilityReport(report);
            assert getPointInTime(new Date(avail.getStartTime() - 2)) == UNKNOWN;
            assert getPointInTime(new Date(avail.getStartTime())) == UP;
            assert getPointInTime(new Date(avail.getStartTime() + 2)) == UP;
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        } finally {
            if (Status.STATUS_ACTIVE == getTransactionManager().getStatus()) {

View Full Code Here


        try {
            setupResource(); // inserts initial UNKNOWN Availability at epoch
            commitAndClose();


            Availability avail;
            long now = System.currentTimeMillis();


            // add a report that says the resource is down
            avail = new Availability(theResource, DOWN);
            AvailabilityReport report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);
            availabilityManager.mergeAvailabilityReport(report);


            // now pretend the agent sent us a report from a previous time period - should insert this in the past
            avail = new Availability(theResource, (now - 600000), UP);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);
            availabilityManager.mergeAvailabilityReport(report);
            assert getPointInTime(new Date(avail.getStartTime() - 2)) == UNKNOWN;


            //check for current availability.
            Date unknownTime = new Date(avail.getStartTime() - 2);
            //make request for avail again but this time requesting most up to date status: should be DOWN
            List<AvailabilityPoint> list = availabilityManager.findAvailabilitiesForResource(overlord,
                theResource.getId(), unknownTime.getTime(), unknownTime.getTime() + 1, 1, true);
            AvailabilityType returnedAvail = list.get(0).getAvailabilityType();
            assert returnedAvail == DOWN : "Expected current avail to be '" + DOWN + "' but was '" + returnedAvail

View Full Code Here


            long now = System.currentTimeMillis();


            // add a report that says the resource is down - reports can't have the same resource in it twice,
            // so just create a size=1 report multiple times
            persistAvailability(new Availability(theResource, (now - 1000000), UP));
            persistAvailability(new Availability(theResource, (now - 900000), DOWN));
            persistAvailability(new Availability(theResource, (now - 800000), UP));
            persistAvailability(new Availability(theResource, (now - 50000), DOWN));
            persistAvailability(new Availability(theResource, (now - 30000), UP));
            persistAvailability(new Availability(theResource, (now), DOWN));


            // now pretend the agent sent us a report from a previous time period - should insert this in the past
            persistAvailability(new Availability(theResource, (now - 600000), UP));


            // its still down though - since we've received a more recent report saying it was down
            assert availabilityManager.getCurrentAvailabilityTypeForResource(overlord, theResource.getId()) == DOWN;


            // now pretend the agent sent us reports from in between our existing time periods
            // this UP record combines with the UP we added previously
            persistAvailability(new Availability(theResource, (now - 300000), UP));


            // its still down though - since we've received a more recent report saying it was down
            assert availabilityManager.getCurrentAvailabilityTypeForResource(overlord, theResource.getId()) == DOWN;


            // this DOWN record combines with the current DOWN
            persistAvailability(new Availability(theResource, (now - 100000), DOWN));


            // this DOWN record is between the two UPs we added earlier. However, because we are RLE,
            // we actually lost the information that we had an UP at both -60000 and -30000.  We just
            // have a RLE interval of UP starting at -60000.  This new DOWN record will add a new row
            // that will indicate we were only UP fro -60000 to -45000 and DOWN thereafter.  This is
            // an odd test and probably will never occur in the wild (why would an agent tell us
            // we were one status in the past but another status further back in the past?)
            persistAvailability(new Availability(theResource, (now - 450000), DOWN));


            // its still down
            assert availabilityManager.getCurrentAvailabilityTypeForResource(overlord, theResource.getId()) == DOWN;


            // let's insert one in the very beginning that is the same type as the current first interval
            persistAvailability(new Availability(theResource, (now - 700000), UP));
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        } finally {
            if (Status.STATUS_ACTIVE == getTransactionManager().getStatus()) {

View Full Code Here

    // tests deprecated method    
    public void testGetAvailabilities2() throws Exception {
        beginTx();


        try {
            Availability avail;


            setupResource();
            commitAndClose();


            Calendar cal = Calendar.getInstance();
            cal.set(Calendar.YEAR, 2000);
            cal.set(Calendar.MONTH, 0);
            cal.set(Calendar.DAY_OF_MONTH, 1);
            cal.set(Calendar.HOUR, 1);
            cal.set(Calendar.MINUTE, 0);
            cal.set(Calendar.SECOND, 0);
            cal.set(Calendar.MILLISECOND, 0);
            Date date1 = cal.getTime();


            cal.set(Calendar.HOUR, 1);
            cal.set(Calendar.MINUTE, 30);
            Date date2 = cal.getTime();


            cal.set(Calendar.HOUR, 2);
            cal.set(Calendar.MINUTE, 0);
            Date date3 = cal.getTime();


            cal.set(Calendar.HOUR, 2);
            cal.set(Calendar.MINUTE, 30);
            Date date4 = cal.getTime();


            cal.set(Calendar.HOUR, 3);
            cal.set(Calendar.MINUTE, 0);
            Date date5 = cal.getTime();


            cal.set(Calendar.HOUR, 3);
            cal.set(Calendar.MINUTE, 30);
            Date date6 = cal.getTime();


            avail = new Availability(theResource, date1.getTime(), UP);
            avail.setEndTime(date2.getTime());
            persistAvailability(avail);


            avail = new Availability(theResource, date2.getTime(), DOWN);
            avail.setEndTime(date3.getTime());
            persistAvailability(avail);


            avail = new Availability(theResource, date3.getTime(), UP);
            avail.setEndTime(date4.getTime());
            persistAvailability(avail);


            avail = new Availability(theResource, date4.getTime(), DOWN);
            avail.setEndTime(date5.getTime());
            persistAvailability(avail);


            avail = new Availability(theResource, date5.getTime(), UP);
            avail.setEndTime(date6.getTime());
            persistAvailability(avail);


            avail = new Availability(theResource, date6.getTime(), DOWN);
            persistAvailability(avail);


            List<AvailabilityPoint> points = availabilityManager.findAvailabilitiesForResource(overlord,
                theResource.getId(), date1.getTime(), date6.getTime(), 5, false);
            assert points.size() == 5;

View Full Code Here

    @Test(enabled = ENABLE_TESTS)
    public void testMergeReport() throws Exception {
        beginTx();


        try {
            Availability avail;
            AvailabilityReport report;


            setupResource();
            commitAndClose();


            long allAvailCount = setUpAvailabilities();


            // we now have 1:00 UP, 1:20 DOWN, 1:40 UP
            Subject overlord = LookupUtil.getSubjectManager().getOverlord();
            avail = availabilityManager.getCurrentAvailabilityForResource(overlord, theResource.getId());
            assert avail.getAvailabilityType() == UP;
            assert availabilityManager.getCurrentAvailabilityTypeForResource(overlord, theResource.getId()) == UP;


            // add something after the start of last, but still be UP (result: nothing added)
            Long currentStartTime = avail.getStartTime();
            avail = new Availability(theResource, (currentStartTime + 3600000), UP);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);
            Thread.sleep(1000);
            availabilityManager.mergeAvailabilityReport(report);


            // the agent should have been updated, but no new rows in availability were added
            Agent agent = LookupUtil.getAgentManager().getAgentByName(theAgent.getName());
            Date lastReport = new Date(agent.getLastAvailabilityReport());
            assert lastReport != null;
            assert countAvailabilitiesInDB().equals(allAvailCount);
            avail = availabilityManager.getCurrentAvailabilityForResource(overlord, theResource.getId());


            // should have returned availability3
            // NOTE: availability3 never got an ID assigned, so we can't compare by id
            //       assert avail.getId() == availability3.getId();
            assert avail.getStartTime().equals(availability3.getStartTime());
            assert avail.getAvailabilityType() == availability3.getAvailabilityType();
            assert Math.abs(avail.getStartTime() - availability3.getStartTime()) < 1000;
            assert avail.getEndTime() == null;
            assert availability3.getEndTime() == null;


            // change start after the start of last (result: add new avail row)
            avail = new Availability(theResource, (currentStartTime + 7200000), DOWN);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);
            Thread.sleep(1000);
            availabilityManager.mergeAvailabilityReport(report);


            // the agent should have been updated and a new row in availability was added (resource is now DOWN)
            agent = LookupUtil.getAgentManager().getAgentByName(theAgent.getName());
            assert new Date(agent.getLastAvailabilityReport()).after(lastReport);
            assert countAvailabilitiesInDB().equals(allAvailCount + 1);
            assert availabilityManager.getCurrentAvailabilityTypeForResource(overlord, theResource.getId()) == DOWN;
            Availability queriedAvail = availabilityManager.getCurrentAvailabilityForResource(overlord,
                theResource.getId());
            assert queriedAvail.getId() > 0;
            assert queriedAvail.getAvailabilityType() == avail.getAvailabilityType();
            assert Math.abs(queriedAvail.getStartTime() - avail.getStartTime()) < 1000;
            assert queriedAvail.getEndTime() == null;
            assert avail.getEndTime() == null;
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        } finally {

View Full Code Here

    @Test(enabled = ENABLE_TESTS)
    public void testMergeReportWithStaleResource() throws Exception {
        beginTx();


        try {
            Availability avail;
            AvailabilityReport report;


            setupResource();
            commitAndClose();


            long allAvailCount = setUpAvailabilities();


            // we now have 1:00 UP, 1:20 DOWN, 1:40 UP
            Subject overlord = LookupUtil.getSubjectManager().getOverlord();
            avail = availabilityManager.getCurrentAvailabilityForResource(overlord, theResource.getId());
            assert avail.getAvailabilityType() == UP;
            assert availabilityManager.getCurrentAvailabilityTypeForResource(overlord, theResource.getId()) == UP;


            // add something after the start of last, but still be UP (result: nothing added)
            Long currentStartTime = avail.getStartTime();
            avail = new Availability(theResource, (currentStartTime + 3600000), UP);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);


            // add something with a stale, non-existent resource. It should be ignored, logging a message,
            // and the rest of the report should be processed.
            avail = new Availability(new Resource(898989), (currentStartTime + 3600000), UP);
            report.addAvailability(avail);


            Thread.sleep(1000);
            availabilityManager.mergeAvailabilityReport(report);


            // the agent should have been updated, but no new rows in availability were added
            Agent agent = LookupUtil.getAgentManager().getAgentByName(theAgent.getName());
            Date lastReport = new Date(agent.getLastAvailabilityReport());
            assert lastReport != null;
            assert countAvailabilitiesInDB().equals(allAvailCount);
            avail = availabilityManager.getCurrentAvailabilityForResource(overlord, theResource.getId());


            // should have returned availability3
            // NOTE: availability3 never got an ID assigned, so we can't compare by id
            //       assert avail.getId() == availability3.getId();
            assert avail.getStartTime().equals(availability3.getStartTime());
            assert avail.getAvailabilityType() == availability3.getAvailabilityType();
            assert Math.abs(avail.getStartTime() - availability3.getStartTime()) < 1000;
            assert avail.getEndTime() == null;
            assert availability3.getEndTime() == null;


            // change start after the start of last (result: add new avail row)
            avail = new Availability(theResource, (currentStartTime + 7200000), DOWN);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);
            Thread.sleep(1000);
            availabilityManager.mergeAvailabilityReport(report);


            // the agent should have been updated and a new row in availability was added (resource is now DOWN)
            agent = LookupUtil.getAgentManager().getAgentByName(theAgent.getName());
            assert new Date(agent.getLastAvailabilityReport()).after(lastReport);
            assert countAvailabilitiesInDB().equals(allAvailCount + 1);
            assert availabilityManager.getCurrentAvailabilityTypeForResource(overlord, theResource.getId()) == DOWN;
            Availability queriedAvail = availabilityManager.getCurrentAvailabilityForResource(overlord,
                theResource.getId());
            assert queriedAvail.getId() > 0;
            assert queriedAvail.getAvailabilityType() == avail.getAvailabilityType();
            assert Math.abs(queriedAvail.getStartTime() - avail.getStartTime()) < 1000;
            assert queriedAvail.getEndTime() == null;
            assert avail.getEndTime() == null;
        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        } finally {

View Full Code Here

    @Test(enabled = ENABLE_TESTS)
    public void testBZ884338_1() throws Exception {
        beginTx();


        try {
            Availability avail;
            AvailabilityReport report;


            setupResource();
            commitAndClose();


            long allAvailCount = setUpAvailabilities();
            assertTrue("should have >= 3 avail records", 3 <= allAvailCount);
            List<Availability> avails = getResourceAvailabilities(theResource);
            // there is always the UNKNOWN period starting at epoch, plus the three created in setup
            assertEquals(avails.toString(), 4, avails.size());


            // we now have 1:00 UP, 1:20 DOWN, 1:40 UP
            avail = availabilityManager.getCurrentAvailabilityForResource(overlord, theResource.getId());
            assert avail.getAvailabilityType() == UP;


            // insert a duplicate current 1:40 UP and an out-of-order 1:20 DOWN, these should be ignored
            Long currentStartTime = avail.getStartTime();
            long newStartTime = currentStartTime;
            avail = new Availability(theResource, newStartTime, UP);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);


            newStartTime = (currentStartTime - (20 * 60 * 1000L));
            avail = new Availability(theResource, newStartTime, DOWN);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);


            Thread.sleep(1000);
            availabilityManager.mergeAvailabilityReport(report);


            // the agent should have been updated, but no new rows in availability were added
            Agent agent = LookupUtil.getAgentManager().getAgentByName(theAgent.getName());
            Date lastReport = new Date(agent.getLastAvailabilityReport());
            assert lastReport != null;
            assertEquals(allAvailCount, countAvailabilitiesInDB().longValue());
            avails = getResourceAvailabilities(theResource);
            assertEquals(avails.toString(), 4, avails.size());


            // avail start times should be unchanged 0, 1:00 (UP), 1:20(DOWN), 1:40(UP)
            avail = avails.get(0); // 0..1:00
            assertTrue(avail.toString(), Math.abs(avail.getStartTime() - 0L) < 1000L);
            assertEquals(avail.toString(), AvailabilityType.UNKNOWN, avail.getAvailabilityType());
            assertTrue(avail.toString(), Math.abs(avail.getEndTime() - avails.get(1).getStartTime()) < 1000L);
            avail = avails.get(1); // 1:00..1:20
            assertTrue(avail.toString(), Math.abs(currentStartTime - (avail.getStartTime() + (40 * 60 * 1000))) < 1000L);
            assertEquals(avail.toString(), AvailabilityType.UP, avail.getAvailabilityType());
            assertTrue(avail.toString(), Math.abs(avail.getEndTime() - avails.get(2).getStartTime()) < 1000L);
            avail = avails.get(2); // 1:20..1:40
            assertTrue(avail.toString(), Math.abs(currentStartTime - (avail.getStartTime() + (20 * 60 * 1000))) < 1000L);
            assertEquals(avail.toString(), AvailabilityType.DOWN, avail.getAvailabilityType());
            assertTrue(avail.toString(), Math.abs(avail.getEndTime() - avails.get(3).getStartTime()) < 1000L);
            avail = avails.get(3); // 1:40
            assertTrue(avail.toString(), Math.abs(currentStartTime - avail.getStartTime()) < 1000L);
            assertEquals(avail.toString(), AvailabilityType.UP, avail.getAvailabilityType());
            assertEquals(avail.toString(), avail.getEndTime(), null);


        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        } finally {

View Full Code Here

    @Test(enabled = ENABLE_TESTS)
    public void testBZ884338_2() throws Exception {
        beginTx();


        try {
            Availability avail;
            AvailabilityReport report;


            setupResource();


            commitAndClose();


            long allAvailCount = setUpAvailabilities();
            assertTrue("should have >= 3 avail records", 3 <= allAvailCount);
            List<Availability> avails = getResourceAvailabilities(theResource);
            // there is always the UNKNOWN period starting at epoch, plus the three created in setup
            assertEquals(avails.toString(), 4, avails.size());


            // we now have 1:00 UP, 1:20 DOWN, 1:40 UP
            avail = availabilityManager.getCurrentAvailabilityForResource(overlord, theResource.getId());


            beginTx();


            avail = em.find(Availability.class, avail.getId());
            assert avail.getAvailabilityType() == UP;


            // mess things up by assigning an end time to the latest avail record.
            Long currentStartTime = avail.getStartTime();


            Long nonNullEndTime = currentStartTime + 1000L;
            avail.setEndTime(nonNullEndTime);
            avail = em.merge(avail);


            commitAndClose();


            // try to insert new avail, this should trigger the repair code
            long newStartTime = (currentStartTime + (5 * 60 * 1000L));
            avail = new Availability(theResource, newStartTime, DOWN);
            report = new AvailabilityReport(false, theAgent.getName());
            report.addAvailability(avail);


            Thread.sleep(1000);
            availabilityManager.mergeAvailabilityReport(report);


            // the end time of avail 4 should have been reset to the start time of avail 5. Avail 5 should have been
            // added and should be DOWN 
            avails = getResourceAvailabilities(theResource);
            assertEquals(avails.toString(), 5, avails.size());


            // avail start times should now be 0, 1:00 (UP), 1:20(DOWN), 1:40(UP), 1:45(DOWN)
            avail = avails.get(0); // 0..1:00
            assertTrue(avail.toString(), Math.abs(avail.getStartTime() - 0L) < 1000L);
            assertEquals(avail.toString(), AvailabilityType.UNKNOWN, avail.getAvailabilityType());
            assertTrue(avail.toString(), Math.abs(avail.getEndTime() - avails.get(1).getStartTime()) < 1000L);
            avail = avails.get(1); // 1:00..1:20
            assertTrue(avail.toString(), Math.abs(newStartTime - (avail.getStartTime() + (45 * 60 * 1000))) < 1000L);
            assertEquals(avail.toString(), AvailabilityType.UP, avail.getAvailabilityType());
            assertTrue(avail.toString(), Math.abs(avail.getEndTime() - avails.get(2).getStartTime()) < 1000L);
            avail = avails.get(2); // 1:20..1:40
            assertTrue(avail.toString(), Math.abs(newStartTime - (avail.getStartTime() + (25 * 60 * 1000))) < 1000L);
            assertEquals(avail.toString(), AvailabilityType.DOWN, avail.getAvailabilityType());
            assertTrue(avail.toString(), Math.abs(avail.getEndTime() - avails.get(3).getStartTime()) < 1000L);
            avail = avails.get(3); // 1:40..1:45
            assertTrue(avail.toString(), Math.abs(newStartTime - (avail.getStartTime() + (5 * 60 * 1000))) < 1000L);
            assertEquals(avail.toString(), AvailabilityType.UP, avail.getAvailabilityType());
            assertTrue(avail.toString(), Math.abs(avail.getEndTime() - avails.get(4).getStartTime()) < 1000L); // THE FIX
            avail = avails.get(4); // 1:45..null
            assertTrue(avail.toString(), Math.abs(newStartTime - avail.getStartTime()) < 1000L);
            assertEquals(avail.toString(), AvailabilityType.DOWN, avail.getAvailabilityType());
            assertEquals(avail.toString(), null, avail.getEndTime());


        } catch (Exception e) {
            e.printStackTrace();
            throw e;
        } finally {

View Full Code Here


            // add a report that says the resources are now up - the report will add one avail for each resource
            // at this point, the resources do not yet have a row in availability - after the merge they will have 1
            AvailabilityReport report = new AvailabilityReport(false, theAgent.getName());
            for (Resource resource : allResources) {
                Availability avail = new Availability(resource, UP);
                report.addAvailability(avail);
            }


            long start = System.currentTimeMillis();
            availabilityManager.mergeAvailabilityReport(report);


            System.out.println("testMergeReportPerformance: mergeAvailabilityReport run 1 took "
                + (System.currentTimeMillis() - start) + "ms");


            AvailabilityType curAvail;
            start = System.currentTimeMillis();


            for (Resource resource : allResources) {
                curAvail = availabilityManager.getCurrentAvailabilityTypeForResource(overlord, resource.getId());
                assert curAvail == UP : curAvail;
            }


            System.out.println("testMergeReportPerformance: checking validity of data 1 took "
                + (System.currentTimeMillis() - start) + "ms");


            // add a report that says the resources are now down - the report will add one avail for each resource
            // at this point, the resources have 1 row in availability - after the merge they will have 2
            report = new AvailabilityReport(false, theAgent.getName());
            for (Resource resource : allResources) {
                Availability avail = new Availability(resource, DOWN);
                report.addAvailability(avail);
            }


            start = System.currentTimeMillis();
            availabilityManager.mergeAvailabilityReport(report);


            System.out.println("testMergeReportPerformance: mergeAvailabilityReport run 2 took "
                + (System.currentTimeMillis() - start) + "ms");


            start = System.currentTimeMillis();


            for (Resource resource : allResources) {
                curAvail = availabilityManager.getCurrentAvailabilityTypeForResource(overlord, resource.getId());
                assert curAvail == DOWN : curAvail;
            }


            System.out.println("testMergeReportPerformance: checking validity of data 2 took "
                + (System.currentTimeMillis() - start) + "ms");


            // add a report that says the resources are now unknown - the report will add one avail for each resource
            // at this point, the resources have 2 rows in availability - after the merge they will have 3
            report = new AvailabilityReport(false, theAgent.getName());
            for (Resource resource : allResources) {
                Availability avail = new Availability(resource, UNKNOWN);
                report.addAvailability(avail);
            }


            start = System.currentTimeMillis();
            availabilityManager.mergeAvailabilityReport(report);

View Full Code Here

        cal.set(Calendar.MINUTE, 40);
        Date splitEnd = cal.getTime();


        long count = countAvailabilitiesInDB();


        availability1 = new Availability(theResource, start.getTime(), UP);
        availability1.setEndTime(splitStart.getTime());
        persistAvailability(availability1);


        availability2 = new Availability(theResource, splitStart.getTime(), DOWN);
        availability2.setEndTime(splitEnd.getTime());
        persistAvailability(availability2);


        availability3 = new Availability(theResource, splitEnd.getTime(), UP);
        persistAvailability(availability3);


        long countNow = countAvailabilitiesInDB();


        assert countNow == (count + 3) : "Did not find three availabilities - instead found: " + countNow;

View Full Code Here

0 1 2 3 4 5 6

TOP

Related Classes of org.rhq.core.domain.measurement.Availability

org.jboss.on.embedded.test.MeasurementUtilTest

org.jboss.on.embedded.ui.CommonActionUtil

org.jboss.on.embedded.ui.NavigationAction

org.jboss.on.embedded.ui.SummaryAction

org.rhq.core.domain.measurement.test.CompositeLoadingTest

org.rhq.core.domain.measurement.test.MeasurementTest

org.rhq.core.domain.resource.composite.ResourceAvailabilitySummaryTest

org.rhq.core.domain.resource.Resource

org.rhq.core.domain.resource.test.ProblemResourceTest

org.rhq.core.domain.resource.test.ResourceTest

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.