import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
private AvailabilityType getCurrentAvailaibility(Resource resource) {
	Subject user = LookupUtil.getSubjectManager().getOverlord();
	AgentManagerLocal agentManager = LookupUtil.getAgentManager();
	AgentClient agentClient = agentManager.getAgentClient(user, resource.getId());
	DiscoveryAgentService discoveryAgentService = agentClient.getDiscoveryAgentService();
	AvailabilityReport currentAvailability = discoveryAgentService.getCurrentAvailability(resource, false);
	// the discoveryAgentService returns the live availability of the requested resource and the last
	// known availabilities of any child resources
	List<Datum> datums = currentAvailability.getResourceAvailability();
	for(Datum datum : datums) {
		if(datum.getResourceId() == resource.getId()) {
			return datum.getAvailabilityType();
		}
	}
	throw new IllegalStateException("Agent didn't respond with requested resource's availability. Resource: "
			+ resource.toString());
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
@Override
protected AvailabilityType doGetAvailability() {
    EJBMonitor ejbMonitor = getApplication().getParent().getEjbMonitor();
    try {
        if (((MBeanClientProxy)ejbMonitor).getMBeanClient().isRegistered()) {
            // TODO: once XM4WAS 0.4.0 has been released, use the variant of the validateStatelessSessionBean method that takes a timeout (and set it to 3 seconds)
            String result = ejbMonitor.validateStatelessSessionBean(getApplicationName(), getModuleName(), getBeanName());
            if (result != null && log.isDebugEnabled()) {
                log.debug("validateStatelessSessionBean result:\n" + result);
            }
            return result == null ? AvailabilityType.UP : AvailabilityType.DOWN;
        } else {
            log.debug("EJBMonitor not available => availability = UP");
            return AvailabilityType.UP;
        }
    } catch (Exception ex) {
        log.debug("Caught exception => availability = DOWN", ex);
        return AvailabilityType.DOWN;
    }
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
@Override
protected AvailabilityType doGetAvailability() {
    AvailabilityType availability = super.doGetAvailability();
    if (availability == AvailabilityType.DOWN) {
        return AvailabilityType.DOWN;
    } else {
        try {
            Integer status = endpoint.getStatus();
            if (log.isDebugEnabled()) {
                log.debug("Status of J2CMessageEndpoint for MDB " + getResourceContext().getResourceKey() + ": " + status);
            }
            return status != null && status.intValue() == 1 ? AvailabilityType.UP : AvailabilityType.DOWN;
        } catch (Exception ex) {
            if (log.isDebugEnabled()) {
                log.debug("Error getting status of J2CMessageEndpoint for MDB " + getResourceContext().getResourceKey(), ex);
            }
            return AvailabilityType.DOWN;
        }
    }
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
void checkRefire(AlertDefinition def) {
    if (log.isDebugEnabled())
        log.debug("check def " + def);
    if (!def.getEnabled() || def.getDeleted() || nonZero(def.getRecoveryId())) {
        log.debug("not enabled, deleted, or recovery");
        return;
    }
    Resource resource = def.getResource();
    if (resource == null) {
        log.debug("no resource");
        return;
    }
    AvailabilityType avail = resource.getCurrentAvailability().getAvailabilityType();
    if (avail != AvailabilityType.DOWN) {
        log.debug("not down; ignore");
        return;
    }
    if (hasAlert(def)) {
        log.debug("already alerted on");
        return;
    }
    for (AlertCondition ac : def.getConditions()) {
        checkCondition(ac);
    }
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
public void checkCondition(AlertCondition ac) {
    AlertDefinition def = ac.getAlertDefinition();
    Resource resource = def.getResource();

    if (ac.getCategory() == AVAIL_DURATION || ac.getCategory() == AVAILABILITY) {
        AlertConditionOperator oper = AlertConditionOperator.valueOf(ac.getName());
        if (ignoreCond.contains(oper)) {
            log.debug("not a condition for down " + oper);
            return;
        }
        log.info("fire alert for not up " + resource);

        AvailabilityType avail = resource.getCurrentAvailability().getAvailabilityType();
        long ctime = System.currentTimeMillis();

        String msg = "refired for state " + avail;
        acml.updateUnmatchedLogByAlertConditionId(ac.getId(), ctime, msg);
        alertManager.fireAlert(def.getId());
        log.debug("done");
    }
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
@BeforeMethod
public void before() {
    cleanup = new AlertCleanup(alertManager, acml);

    Resource r = new Resource();
    def = new AlertDefinition();
    def.setId(555);
    def.setEnabled(true);
    def.setDeleted(false);
    def.setResource(r);
    avail = new ResourceAvailability(r, AvailabilityType.DOWN);
    r.setCurrentAvailability(avail);
    AlertCondition condition = new AlertCondition(def, AlertConditionCategory.AVAIL_DURATION);
    condition.setName(AlertConditionOperator.AVAIL_GOES_DOWN.name());
    def.addCondition(condition);
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
@Override
public AvailabilityType getAvailability() {
    InputStream is;
    try {
        is = url.openStream();
        try {
            this.map = parse(IOUtils.toString(is));
        } finally {
            is.close();
        }
    } catch (Exception e) {
        log.warn("cannot parse " + url, e);
        return AvailabilityType.DOWN;
    }
    return AvailabilityType.UP;
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
/**
 * Returns UP if container is found, and in active state.
 */
public AvailabilityType getAvailability() {
    boolean found = false;
    try {
        List<Map<String, Object>> l = app.getOperatorData();
        int count = 0;
        for (Map<String, Object> op: l) {
            String name  = (String) op.get("name");
            opId = (String) op.get("id");
            if (name.equals(this.name) && instance == count++) {
                this.stats = op;
                String status = (String) stats.get("status");
                if (!ACTIVE.equals(status)) {
                    return AvailabilityType.DOWN;
                }
                found = true;
                break;
            }
        }
    } catch (Exception e) {
        log.warn("operator " + this, e);
        return AvailabilityType.DOWN;
    }
    return found ? AvailabilityType.UP : AvailabilityType.DOWN;
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
/**
 * Returns UP if container is found, and in active state.
 */
@Override
public AvailabilityType getAvailability() {
    boolean found = false;
    try {
        List<Map<String, Object>> l = app.getContainerData();
        String fullKey = getFullKey();
        for (Map<String, Object> con: l) {
            String id = (String) con.get("id");
            if (id.equals(fullKey)) {
                this.stats = con;
                String state = (String) stats.get("state");
                if (!ACTIVE.equals(state)) {
                    return AvailabilityType.DOWN;
                }
                found = true;
                break;
            }
        }
    } catch (Exception e) {
        log.warn("container " + this, e);
        return AvailabilityType.DOWN;
    }
    return found ? AvailabilityType.UP : AvailabilityType.DOWN;
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
private void refresh(Configuration conf) throws Exception {
    long start = System.nanoTime();
    ProcessExecutionResults res = callVD(conf);
    String output = res.getCapturedOutput();
    if (res.getExitCode() == null)
        throw new RuntimeException("Process expired");
    int code = res.getExitCode();
    if (code != 0) {
        log.warn("vd failed with output: " + output);
        throw new RuntimeException("Non-zero exit status");
    }
    JSONParser reader = new JSONParser();
    verdad = (Map)reader.parse(output);
    avail = AvailabilityType.UP;

    int hc = output.hashCode();
    if (verdadHash != 0 && verdadHash != hc) {
        log.debug("vd tree changed, request discovery");
        inventoryContext.requestDeferredChildResourcesDiscovery();
    }
    verdadHash = hc;
    elapsed = (int) (System.nanoTime() - start);
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
/**
 * Returns UP if the information can be obtained and
 * the metrics file can be read.
 */
@Override
public AvailabilityType getAvailability() {
    try {
        log.debug("probe");
        Service service = SplunkDiscovery.service(config);
        serviceInfo = service.getInfo();
        service.logout();
        /*
        Splunk file rotation makes the metrics file unreadable
        This is Splunk case 117457
        log.debug("tail");
        tail.read();
        */
        log.debug("done");
        return AvailabilityType.UP;
    } catch (Exception e) {
        log.debug("failed checking splunk", e);
        return AvailabilityType.DOWN;
    }
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
@Test
public void up() throws Exception {
    log.info("testUp");
    sleep = 150;
    assertEquals(AvailabilityType.UP, component.getAvailability());
    MeasurementReport report = getMeasurementReport(component);
    Double rt = getValue(report, "responseTime");
    assertNotNull(rt);
    assertTrue(rt > 100 && rt < 200);
    assertEquals((double)body.length(), getValue(report, "responseSize"));

    assertEquals(42.0, getValue(report, regexApple));
    assertEquals(49.0, getValue(report, regexBanana));
    assertEquals(13.0, ComponentTest.map(report).get("#x-head"));

    // TODO figure out how to test this
    assertEquals("ServletServer_Servlet", component.getVersion());
    component.clearState();
    assertEquals(null, component.getVersion());
    assertEquals(AvailabilityType.UP, component.getAvailability());
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
/**
 * Returns UP if able to obtain one of the defined measurement mib.
 */
@Override
public AvailabilityType getAvailability() {
    Set<MeasurementDefinition> mds = this.definitions;
    if (!mds.isEmpty()) {
        MeasurementDefinition md = mds.iterator().next();
        OID oid = index.getNameRecord(md.getName()).getOid0();
        try {
            Variable variable = snmp.get(oid);
            if (variable.isException())
                return DOWN;
        } catch (IOException e) {
            return DOWN;
        }
    }
    return UP;
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
/**
 * Returns DOWN if the table row no longer exists or can be read.
 */
@Override
public AvailabilityType getAvailability() {
    Set<MeasurementDefinition> mds = this.definitions;
    if (!mds.isEmpty()) {
        MeasurementDefinition md = mds.iterator().next();
        OID oid = oid(md.getName());
        try {
            Variable variable = snmp.get(oid);
            if (variable.isException())
                return DOWN;
        } catch (IOException e) {
            return DOWN;
        }
    }
    return UP;
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
@Override
public AvailabilityType getAvailability() {

    final AvailabilityType availability = super.getAvailability();

    if (availability == AvailabilityType.UP && statsObjectName != null) {
        try {
            if (isMBeanAvailable(getStatsBean())) {
                return AvailabilityType.UP;
            } else {
                return AvailabilityType.DOWN;
            }
        } catch (RuntimeException e) {
            if (this.statsBean != null) {
                // Retry by connecting to a new parent connection (this bean might have been connected to by an old
                // provider that's since been recreated).
                this.statsBean = null;
                if (isMBeanAvailable(getStatsBean())) {
                    return AvailabilityType.UP;
                } else {
                    return AvailabilityType.DOWN;
                }
            } else {
                throw e;
            }
        }
    }
    
    return availability;
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
public AvailabilityType getAvailability() {
    if ((connectionProvider) == null || !connectionProvider.isConnected()) {
        try {
            internalStart();
        } catch (Exception e) {
            log.debug("Still unable to reconnect to " + context.getResourceType() + "[" + context.getResourceKey()
                + "] due to error: " + e);
        }
    }

    return ((connectionProvider != null) && connectionProvider.isConnected()) ? AvailabilityType.UP
        : AvailabilityType.DOWN;
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
@Override
protected AvailabilityType doGetAvailability() {
    try {
        getContext().testConnection();
        return AvailabilityType.UP;
    } catch (Exception ex) {
        if (log.isDebugEnabled()) {
            log.debug("Test connection failed ==> availability = DOWN", ex);
        }
        return AvailabilityType.DOWN;
    }
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
@Override
public final AvailabilityType getAvailability() {
       try {
           if (!isConfigured()) {
			log.debug("isConfigured=false => availability == MISSING");
			return AvailabilityType.MISSING;
           } else {
               log.debug("isConfigured=true; continue with checking the runtime state");
           }
       } catch (Exception ex) {
		log.warn("Caught exception thrown by isConfigured => availability == UNKNOWN", ex);
		return AvailabilityType.UNKNOWN;
       }
       return doGetAvailability();
   }
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
protected AvailabilityType doGetAvailability() {
    if (log.isDebugEnabled()) {
        log.debug("Starting to determine availability of " + jndiName);
    }
    try {
        mbean.getObjectName(true);
        log.debug("MBean found => availability == UP");
        return AvailabilityType.UP;
    } catch (Exception ex) {
        log.debug("MBean not found => availability == DOWN", ex);
        return AvailabilityType.DOWN;
    }
}
 

import org.rhq.core.domain.measurement.AvailabilityType; //导入依赖的package包/类
@Override
protected AvailabilityType doGetAvailability() {
    try {
        if (getParent().isActive()) {
            return gatewayLink.isActive() ? AvailabilityType.UP : AvailabilityType.DOWN;
        } else {
            log.debug("Message engine not started ==> availability = UP");
            return AvailabilityType.UP;
        }
    } catch (Exception ex) {
        log.debug("Call to isActive failed ==> availability = DOWN", ex);
        return AvailabilityType.DOWN;
    }
}