java类javax.management.relation.Role的实例源码

public static void main(String[] args) throws Exception {
    MBeanServer mbs = MBeanServerFactory.newMBeanServer();
    ObjectName relSvcName = new ObjectName("a:type=relationService");
    RelationServiceMBean relSvc =
            JMX.newMBeanProxy(mbs, relSvcName, RelationServiceMBean.class);
    mbs.createMBean("javax.management.relation.RelationService",
                    relSvcName,
                    new Object[] {Boolean.TRUE},
                    new String[] {"boolean"});

    final BlockingQueue<Notification> q =
            new ArrayBlockingQueue<Notification>(100);
    NotificationListener qListener = new NotificationListener() {
        public void handleNotification(Notification notification,
                                       Object handback) {
            q.add(notification);
        }
    };
    mbs.addNotificationListener(relSvcName, qListener, null, null);

    RoleInfo leftInfo =
        new RoleInfo("left", "javax.management.timer.TimerMBean");
    RoleInfo rightInfo =
        new RoleInfo("right", "javax.management.timer.Timer");
    relSvc.createRelationType("typeName", new RoleInfo[] {leftInfo, rightInfo});
    ObjectName timer1 = new ObjectName("a:type=timer,number=1");
    ObjectName timer2 = new ObjectName("a:type=timer,number=2");
    mbs.createMBean("javax.management.timer.Timer", timer1);
    mbs.createMBean("javax.management.timer.Timer", timer2);

    Role leftRole =
        new Role("left", Arrays.asList(new ObjectName[] {timer1}));
    Role rightRole =
        new Role("right", Arrays.asList(new ObjectName[] {timer2}));
    RoleList roles =
        new RoleList(Arrays.asList(new Role[] {leftRole, rightRole}));

    final int NREPEAT = 10;

    for (int i = 0; i < NREPEAT; i++) {
        relSvc.createRelation("relationName", "typeName", roles);
        relSvc.removeRelation("relationName");
    }

    Notification firstNotif = q.remove();
    long seqNo = firstNotif.getSequenceNumber();
    for (int i = 0; i < NREPEAT * 2 - 1; i++) {
        Notification n = q.remove();
        long nSeqNo = n.getSequenceNumber();
        if (nSeqNo != seqNo + 1) {
            throw new Exception(
                    "TEST FAILED: expected seqNo " + (seqNo + 1) + "; got " +
                    nSeqNo);
        }
        seqNo++;
    }
    System.out.println("TEST PASSED: got " + (NREPEAT * 2) + " notifications " +
            "with contiguous sequence numbers");
}

public static void main(String[] args) throws Exception {
    MBeanServer mbs = MBeanServerFactory.newMBeanServer();
    ObjectName relSvcName = new ObjectName("a:type=relationService");
    RelationServiceMBean relSvc =
            JMX.newMBeanProxy(mbs, relSvcName, RelationServiceMBean.class);
    mbs.createMBean("javax.management.relation.RelationService",
                    relSvcName,
                    new Object[] {Boolean.TRUE},
                    new String[] {"boolean"});

    final BlockingQueue<Notification> q =
            new ArrayBlockingQueue<Notification>(100);
    NotificationListener qListener = new NotificationListener() {
        public void handleNotification(Notification notification,
                                       Object handback) {
            q.add(notification);
        }
    };
    mbs.addNotificationListener(relSvcName, qListener, null, null);

    RoleInfo leftInfo =
        new RoleInfo("left", "javax.management.timer.TimerMBean");
    RoleInfo rightInfo =
        new RoleInfo("right", "javax.management.timer.Timer");
    relSvc.createRelationType("typeName", new RoleInfo[] {leftInfo, rightInfo});
    ObjectName timer1 = new ObjectName("a:type=timer,number=1");
    ObjectName timer2 = new ObjectName("a:type=timer,number=2");
    mbs.createMBean("javax.management.timer.Timer", timer1);
    mbs.createMBean("javax.management.timer.Timer", timer2);

    Role leftRole =
        new Role("left", Arrays.asList(new ObjectName[] {timer1}));
    Role rightRole =
        new Role("right", Arrays.asList(new ObjectName[] {timer2}));
    RoleList roles =
        new RoleList(Arrays.asList(new Role[] {leftRole, rightRole}));

    final int NREPEAT = 10;

    for (int i = 0; i < NREPEAT; i++) {
        relSvc.createRelation("relationName", "typeName", roles);
        relSvc.removeRelation("relationName");
    }

    Notification firstNotif = q.remove();
    long seqNo = firstNotif.getSequenceNumber();
    for (int i = 0; i < NREPEAT * 2 - 1; i++) {
        Notification n = q.remove();
        long nSeqNo = n.getSequenceNumber();
        if (nSeqNo != seqNo + 1) {
            throw new Exception(
                    "TEST FAILED: expected seqNo " + (seqNo + 1) + "; got " +
                    nSeqNo);
        }
        seqNo++;
    }
    System.out.println("TEST PASSED: got " + (NREPEAT * 2) + " notifications " +
            "with contiguous sequence numbers");
}

public static void main(String[] args) throws Exception {
    MBeanServer mbs = MBeanServerFactory.newMBeanServer();
    ObjectName relSvcName = new ObjectName("a:type=relationService");
    RelationServiceMBean relSvc =
            JMX.newMBeanProxy(mbs, relSvcName, RelationServiceMBean.class);
    mbs.createMBean("javax.management.relation.RelationService",
                    relSvcName,
                    new Object[] {Boolean.TRUE},
                    new String[] {"boolean"});

    final BlockingQueue<Notification> q =
            new ArrayBlockingQueue<Notification>(100);
    NotificationListener qListener = new NotificationListener() {
        public void handleNotification(Notification notification,
                                       Object handback) {
            q.add(notification);
        }
    };
    mbs.addNotificationListener(relSvcName, qListener, null, null);

    RoleInfo leftInfo =
        new RoleInfo("left", "javax.management.timer.TimerMBean");
    RoleInfo rightInfo =
        new RoleInfo("right", "javax.management.timer.Timer");
    relSvc.createRelationType("typeName", new RoleInfo[] {leftInfo, rightInfo});
    ObjectName timer1 = new ObjectName("a:type=timer,number=1");
    ObjectName timer2 = new ObjectName("a:type=timer,number=2");
    mbs.createMBean("javax.management.timer.Timer", timer1);
    mbs.createMBean("javax.management.timer.Timer", timer2);

    Role leftRole =
        new Role("left", Arrays.asList(new ObjectName[] {timer1}));
    Role rightRole =
        new Role("right", Arrays.asList(new ObjectName[] {timer2}));
    RoleList roles =
        new RoleList(Arrays.asList(new Role[] {leftRole, rightRole}));

    final int NREPEAT = 10;

    for (int i = 0; i < NREPEAT; i++) {
        relSvc.createRelation("relationName", "typeName", roles);
        relSvc.removeRelation("relationName");
    }

    Notification firstNotif = q.remove();
    long seqNo = firstNotif.getSequenceNumber();
    for (int i = 0; i < NREPEAT * 2 - 1; i++) {
        Notification n = q.remove();
        long nSeqNo = n.getSequenceNumber();
        if (nSeqNo != seqNo + 1) {
            throw new Exception(
                    "TEST FAILED: expected seqNo " + (seqNo + 1) + "; got " +
                    nSeqNo);
        }
        seqNo++;
    }
    System.out.println("TEST PASSED: got " + (NREPEAT * 2) + " notifications " +
            "with contiguous sequence numbers");
}

public static void main(String[] args) throws Exception {
    MBeanServer mbs = MBeanServerFactory.newMBeanServer();
    ObjectName relSvcName = new ObjectName("a:type=relationService");
    RelationServiceMBean relSvc =
            JMX.newMBeanProxy(mbs, relSvcName, RelationServiceMBean.class);
    mbs.createMBean("javax.management.relation.RelationService",
                    relSvcName,
                    new Object[] {Boolean.TRUE},
                    new String[] {"boolean"});

    final BlockingQueue<Notification> q =
            new ArrayBlockingQueue<Notification>(100);
    NotificationListener qListener = new NotificationListener() {
        public void handleNotification(Notification notification,
                                       Object handback) {
            q.add(notification);
        }
    };
    mbs.addNotificationListener(relSvcName, qListener, null, null);

    RoleInfo leftInfo =
        new RoleInfo("left", "javax.management.timer.TimerMBean");
    RoleInfo rightInfo =
        new RoleInfo("right", "javax.management.timer.Timer");
    relSvc.createRelationType("typeName", new RoleInfo[] {leftInfo, rightInfo});
    ObjectName timer1 = new ObjectName("a:type=timer,number=1");
    ObjectName timer2 = new ObjectName("a:type=timer,number=2");
    mbs.createMBean("javax.management.timer.Timer", timer1);
    mbs.createMBean("javax.management.timer.Timer", timer2);

    Role leftRole =
        new Role("left", Arrays.asList(new ObjectName[] {timer1}));
    Role rightRole =
        new Role("right", Arrays.asList(new ObjectName[] {timer2}));
    RoleList roles =
        new RoleList(Arrays.asList(new Role[] {leftRole, rightRole}));

    final int NREPEAT = 10;

    for (int i = 0; i < NREPEAT; i++) {
        relSvc.createRelation("relationName", "typeName", roles);
        relSvc.removeRelation("relationName");
    }

    Notification firstNotif = q.remove();
    long seqNo = firstNotif.getSequenceNumber();
    for (int i = 0; i < NREPEAT * 2 - 1; i++) {
        Notification n = q.remove();
        long nSeqNo = n.getSequenceNumber();
        if (nSeqNo != seqNo + 1) {
            throw new Exception(
                    "TEST FAILED: expected seqNo " + (seqNo + 1) + "; got " +
                    nSeqNo);
        }
        seqNo++;
    }
    System.out.println("TEST PASSED: got " + (NREPEAT * 2) + " notifications " +
            "with contiguous sequence numbers");
}

public static void main(String[] args) throws Exception {
    MBeanServer mbs = MBeanServerFactory.newMBeanServer();
    ObjectName relSvcName = new ObjectName("a:type=relationService");
    RelationServiceMBean relSvc =
            JMX.newMBeanProxy(mbs, relSvcName, RelationServiceMBean.class);
    mbs.createMBean("javax.management.relation.RelationService",
                    relSvcName,
                    new Object[] {Boolean.TRUE},
                    new String[] {"boolean"});

    final BlockingQueue<Notification> q =
            new ArrayBlockingQueue<Notification>(100);
    NotificationListener qListener = new NotificationListener() {
        public void handleNotification(Notification notification,
                                       Object handback) {
            q.add(notification);
        }
    };
    mbs.addNotificationListener(relSvcName, qListener, null, null);

    RoleInfo leftInfo =
        new RoleInfo("left", "javax.management.timer.TimerMBean");
    RoleInfo rightInfo =
        new RoleInfo("right", "javax.management.timer.Timer");
    relSvc.createRelationType("typeName", new RoleInfo[] {leftInfo, rightInfo});
    ObjectName timer1 = new ObjectName("a:type=timer,number=1");
    ObjectName timer2 = new ObjectName("a:type=timer,number=2");
    mbs.createMBean("javax.management.timer.Timer", timer1);
    mbs.createMBean("javax.management.timer.Timer", timer2);

    Role leftRole =
        new Role("left", Arrays.asList(new ObjectName[] {timer1}));
    Role rightRole =
        new Role("right", Arrays.asList(new ObjectName[] {timer2}));
    RoleList roles =
        new RoleList(Arrays.asList(new Role[] {leftRole, rightRole}));

    final int NREPEAT = 10;

    for (int i = 0; i < NREPEAT; i++) {
        relSvc.createRelation("relationName", "typeName", roles);
        relSvc.removeRelation("relationName");
    }

    Notification firstNotif = q.remove();
    long seqNo = firstNotif.getSequenceNumber();
    for (int i = 0; i < NREPEAT * 2 - 1; i++) {
        Notification n = q.remove();
        long nSeqNo = n.getSequenceNumber();
        if (nSeqNo != seqNo + 1) {
            throw new Exception(
                    "TEST FAILED: expected seqNo " + (seqNo + 1) + "; got " +
                    nSeqNo);
        }
        seqNo++;
    }
    System.out.println("TEST PASSED: got " + (NREPEAT * 2) + " notifications " +
            "with contiguous sequence numbers");
}

/**
 * This testcase verifies MBeanToUnregister field in notifications.
 */

public Result testRemovalNotification() throws Exception {

    incorrectNotificationFlag = false;

    MBeanServer mBeanServer = MBeanServerFactory.createMBeanServer();

    RelationService relationService = new RelationService(true);
    ObjectName relationServiceName = new ObjectName(
            "mBeanServer:type=RelationService,name=rs");
    mBeanServer.registerMBean(relationService, relationServiceName);

    NotificationFilterSupport filter = new NotificationFilterSupport();
    filter.enableType("jmx.relation");
    relationService.addNotificationListener(this, filter, null);
    checkNotifications = true;

    RoleInfo[] roleInfo = new RoleInfo[1];
    roleInfo[0] = new RoleInfo("unitRole", classPath, true, true, 1, 2,
            "Unit role");

    // Creating an Internal Relation Type
    relationService.createRelationType("internalRelationType", roleInfo);

    UnitMBean unit = new Unit();
    ObjectName unitName = new ObjectName("mBeanServer:type=Unit,name=Unit");
    mBeanServer.registerMBean(unit, unitName);

    ArrayList unitList = new ArrayList();
    unitList.add(unitName);

    Role unitRole = new Role("unitRole", unitList);
    RoleList unitRoles = new RoleList();
    unitRoles.add(unitRole);

    // Now Create relations between unit MBeans

    // Notification Data
    relationNotification = new RelationNotificationForCompare(
            "jmx.relation.creation.basic", relationService, 1, 10,
            "Creation of relation internalRelation", "internalRelation",
            "internalRelationType", null, null);

    relationService.createRelation("internalRelation",
            "internalRelationType", unitRoles);

    // Notification Data
    relationNotification = new RelationNotificationForCompare(
            "jmx.relation.removal.basic", relationService, 2, 10,
            "Removal of relation internalRelation", "internalRelation",
            "internalRelationType", null, new ArrayList());

    relationService.removeRelation("internalRelation");

    if (incorrectNotificationFlag) {
        return failed("IncorrectNotifications (see log for more information)");
    }
    return passed();
}

/**
 * Step by step for verification that relation is removed as soon as its
 * relation type is removed.
 * <ul>
 * <li>a. Create relation
 * <li>b. Remove relation type
 * <li>c. Check that relation isn't present in relation service
 * </ul>
 */
public Result testRemoveRelationType() throws Exception {

    MBeanServer mBeanServer = MBeanServerFactory.createMBeanServer();

    RelationService relationService = new RelationService(true);
    ObjectName relationServiceName = new ObjectName(
            "mBeanServer:type=RelationService,name=rs");
    mBeanServer.registerMBean(relationService, relationServiceName);

    RoleInfo[] roleInfo = new RoleInfo[1];
    roleInfo[0] = new RoleInfo("unitRole", classPath, true, true, 1, 2,
            "Unit role");

    /* Creating an Internal Relation Type */
    relationService.createRelationType("internalRelationType", roleInfo);

    /* 2 MBean objects to be associate */
    UnitMBean unit1 = new Unit();
    ObjectName unit1Name = new ObjectName(
            "mBeanServer:type=Unit,name=Unit1");
    mBeanServer.registerMBean(unit1, unit1Name);

    /* Create Role */
    ArrayList unitList = new ArrayList();
    unitList.add(unit1Name);

    Role unitRole = new Role("unitRole", unitList);
    RoleList unitRoles = new RoleList();
    unitRoles.add(unitRole);

    /* Now Create relations between unit MBeans */
    relationService.createRelation("internalRelation",
            "internalRelationType", unitRoles);

    ERelation externalRelation = new ERelation("externalRelation",
            relationServiceName, mBeanServer, "internalRelationType",
            unitRoles);
    mBeanServer.registerMBean(externalRelation, externalRelation
            .getRelationON());

    /* Relations created. Now Remove Relation type */
    relationService.removeRelationType("internalRelationType");

    /* Check relations are removed */
    if (relationService.hasRelation("internalRelation").booleanValue()
            && relationService.hasRelation("externalRelation")
                    .booleanValue()) {
        return failed("Relation type had been removed, but relation is not");
    }

    return passed();
}

/**
 * Test creates 2 relation types with equals names and RoleInfos, but
 * referred to different relation services. Test checks that when first
 * relation type creates relation, second relation type is not affected
 */
public Result testTheSameRelationType() throws Exception {

    MBeanServer mBeanServer = MBeanServerFactory.createMBeanServer();

    RelationService firstRelationService = new RelationService(true);
    RelationService secondRelationService = new RelationService(true);

    ObjectName firstRelationServiceName = new ObjectName(
            "mBeanServer:type=RelationService,name=first");
    ObjectName secondRelationServiceName = new ObjectName(
            "mBeanServer:type=RelationService,name=second");

    mBeanServer.registerMBean(firstRelationService,
            firstRelationServiceName);
    mBeanServer.registerMBean(secondRelationService,
            secondRelationServiceName);

    RoleInfo roleInfo = new RoleInfo("usualRole", classPath, true, true, 1,
            1, "usual role");

    ERelationType eRelationType = new ERelationType("relationType",
            roleInfo);

    firstRelationService.addRelationType(eRelationType);
    secondRelationService.addRelationType(eRelationType);

    UnitMBean unit1 = new Unit();

    ObjectName unit1Name = new ObjectName(
            "mBeanServer:type=Unit,name=Unit1");
    mBeanServer.registerMBean(unit1, unit1Name);

    ArrayList unitList = new ArrayList();
    unitList.add(unit1Name);

    Role singleUnitRole = new Role("usualRole", unitList);

    RoleList singleunitRoles = new RoleList();
    singleunitRoles.add(singleUnitRole);

    firstRelationService.createRelation("relation", "relationType",
            singleunitRoles);

    if (secondRelationService.hasRelation("relation").booleanValue()) {
        return failed("RelationType Mismatch");
    }
    return passed();
}

/**
 * In this test External relation unregistered MBeans by itself. After this
 * verified relation service consistency.
 */

public Result testSelfUnregistration() throws Exception {

    MBeanServer mBeanServer = MBeanServerFactory.createMBeanServer();

    RelationService relationService = new RelationService(true);
    ObjectName relationServiceName = new ObjectName(
            "mBeanServer:type=RelationService,name=rs");
    mBeanServer.registerMBean(relationService, relationServiceName);

    RoleInfo[] roleInfo = new RoleInfo[1];
    roleInfo[0] = new RoleInfo("unitRole", classPath, true, true, 1, 2,
            "Unit role");

    // Creating an Internal Relation Type
    relationService.createRelationType("internalRelationType", roleInfo);

    // Registering 2 MBean objects
    UnitMBean unit1 = new Unit();
    ObjectName unit1Name = new ObjectName(
            "mBeanServer:type=Unit,name=Unit1");
    mBeanServer.registerMBean(unit1, unit1Name);

    ArrayList unitList = new ArrayList();

    unitList.add(unit1Name);
    Role unitRole = new Role("unitRole", unitList);
    RoleList unitRoles = new RoleList();
    unitRoles.add(unitRole);

    ERelation externalRelation = new ERelation("externalRelation",
            relationServiceName, mBeanServer, "internalRelationType",
            unitRoles);
    mBeanServer.registerMBean(externalRelation, externalRelation
            .getRelationON());
    relationService.addRelation(externalRelation.getRelationON());

    externalRelation.unregisterMBean(unit1Name);

    if (relationService.hasRelation("externalRelation").booleanValue()) {
        return failed("Consistency Failed");
    }
    return passed();
}

/**
 * This test verifies findReferencingRelations method
 */

public Result testRelationIdMap() throws Exception {

    MBeanServer mBeanServer = MBeanServerFactory.createMBeanServer();

    // Register Relation Service
    RelationService relationService = new RelationService(true);
    ObjectName relationServiceName = new ObjectName(
            "mBeanServer:type=RelationService,name=rs");
    mBeanServer.registerMBean(relationService, relationServiceName);

    // Create Role Information Array
    RoleInfo[] roleInfo = new RoleInfo[1];
    roleInfo[0] = new RoleInfo("unitRole", classPath, true, true, 1, 2,
            "Unit role");

    // Creating an Internal Relation Type
    relationService.createRelationType("internalRelationType", roleInfo);

    // Registering 2 MBean objects
    UnitMBean unit1 = new Unit();

    ObjectName unit2Name = new ObjectName(
            "mBeanServer:type=Unit,name=Unit2");
    mBeanServer.registerMBean(unit1, unit2Name);

    ObjectName unit1Name = new ObjectName(
            "mBeanServer:type=Unit,name=Unit1");
    mBeanServer.registerMBean(unit1, unit1Name);

    // Create RoleLists for single unit and double unit relations
    ArrayList unitList = new ArrayList();

    unitList.add(unit1Name);
    Role singleUnitRole = new Role("unitRole", unitList);

    unitList.add(unit2Name);
    Role doubleUnitRole = new Role("unitRole", unitList);

    RoleList singleunitRoles = new RoleList();
    singleunitRoles.add(singleUnitRole);

    RoleList doubleunitRoles = new RoleList();
    doubleunitRoles.add(doubleUnitRole);

    // Create 2 Internal Relations
    relationService.createRelation("internalRelationSingle",
            "internalRelationType", singleunitRoles);
    relationService.createRelation("internalRelationDouble",
            "internalRelationType", doubleunitRoles);
    ERelation externalRelation = new ERelation("externalRelation",
            relationServiceName, mBeanServer, "internalRelationType",
            doubleunitRoles);
    mBeanServer.registerMBean(externalRelation, externalRelation
            .getRelationON());
    relationService.addRelation(externalRelation.getRelationON());

    if ((!relationService.findReferencingRelations(unit2Name,
            "internalRelationType", "unitRole").containsKey(
            "internalRelationDouble"))
            || (!relationService.findReferencingRelations(unit1Name,
                    "internalRelationType", "unitRole").containsKey(
                    "internalRelationDouble"))
            || (!relationService.findReferencingRelations(unit1Name,
                    "internalRelationType", "unitRole").containsKey(
                    "internalRelationSingle"))
            || (!relationService.findReferencingRelations(unit1Name,
                    "internalRelationType", "unitRole").containsKey(
                    "externalRelation"))
            || (!relationService.findReferencingRelations(unit2Name,
                    "internalRelationType", "unitRole").containsKey(
                    "externalRelation"))) {
        log.info(relationService.findReferencingRelations(unit1Name,
                "internalRelationType", "unitRole").toString());
        return failed("findReferencingRelations method is incorrect");
    }
    return passed();
}