Java EntityOwnershipState类代码示例

import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; //导入依赖的package包/类
@Test
public void testInit() throws CandidateAlreadyRegisteredException {
    // Indicate that this is the owner
    when(entityOwnershipService.getOwnershipState(any(Entity.class))).thenReturn(
            Optional.of(new EntityOwnershipState(true, true)));

    try (SouthboundProvider southboundProvider = new SouthboundProvider(
            getDataBroker(),
            entityOwnershipService,
            Mockito.mock(OvsdbConnection.class),
            Mockito.mock(DOMSchemaService.class),
            Mockito.mock(BindingNormalizedNodeSerializer.class))) {

        // Initiate the session
        southboundProvider.init();

        // Verify that at least one listener was registered
        verify(entityOwnershipService, atLeastOnce()).registerListener(
                anyString(), any(EntityOwnershipListener.class));

        // Verify that a candidate was registered
        verify(entityOwnershipService).registerCandidate(any(Entity.class));
    }
}
 

import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; //导入依赖的package包/类
@Test
public void testGetDb() {
    when(entityOwnershipService.getOwnershipState(any(Entity.class))).thenReturn(
            Optional.of(new EntityOwnershipState(true, true)));

    try (SouthboundProvider southboundProvider = new SouthboundProvider(
            getDataBroker(),
            entityOwnershipService,
            Mockito.mock(OvsdbConnection.class),
            Mockito.mock(DOMSchemaService.class),
            Mockito.mock(BindingNormalizedNodeSerializer.class))) {

        southboundProvider.init();

        assertEquals(getDataBroker(), SouthboundProvider.getDb());
    }
}
 

import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; //导入依赖的package包/类
private Optional<EntityOwnershipState> toEntityOwnershipState(
        Optional<org.opendaylight.mdsal.eos.common.api.EntityOwnershipState> from) {
    if(!from.isPresent()) {
        return Optional.absent();
    }

    org.opendaylight.mdsal.eos.common.api.EntityOwnershipState fromState = from.get();
    return Optional.of(new EntityOwnershipState(
            fromState == org.opendaylight.mdsal.eos.common.api.EntityOwnershipState.IS_OWNER,
            fromState != org.opendaylight.mdsal.eos.common.api.EntityOwnershipState.NO_OWNER));
}
 

import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; //导入依赖的package包/类
private void registerEntityForOwnership(OvsdbConnectionInstance ovsdbConnectionInstance) {

        Entity candidateEntity = getEntityFromConnectionInstance(ovsdbConnectionInstance);
        entityConnectionMap.put(candidateEntity, ovsdbConnectionInstance);
        ovsdbConnectionInstance.setConnectedEntity(candidateEntity);
        try {
            EntityOwnershipCandidateRegistration registration =
                    entityOwnershipService.registerCandidate(candidateEntity);
            ovsdbConnectionInstance.setDeviceOwnershipCandidateRegistration(registration);
            LOG.info("OVSDB entity {} is registered for ownership.", candidateEntity);

            //If entity already has owner, it won't get notification from EntityOwnershipService
            //so cache the connection instances.
            Optional<EntityOwnershipState> ownershipStateOpt =
                    entityOwnershipService.getOwnershipState(candidateEntity);
            if (ownershipStateOpt.isPresent()) {
                EntityOwnershipState ownershipState = ownershipStateOpt.get();
                if (ownershipState.hasOwner() && !ownershipState.isOwner()) {
                    LOG.info("OVSDB entity {} is already owned by other southbound plugin "
                                    + "instance, so *this* instance is NOT an OWNER of the device",
                            ovsdbConnectionInstance.getConnectionInfo());
                    putConnectionInstance(ovsdbConnectionInstance.getMDConnectionInfo(),ovsdbConnectionInstance);
                }
            }
        } catch (CandidateAlreadyRegisteredException e) {
            LOG.warn("OVSDB entity {} was already registered for ownership", candidateEntity, e);
        }

    }
 

import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; //导入依赖的package包/类
/**
 * Used by blueprint when starting the container.
 */
public void init() {
    LOG.info("SouthboundProvider Session Initiated");
    this.txInvoker = new TransactionInvokerImpl(db);
    cm = new OvsdbConnectionManager(db,txInvoker,entityOwnershipService, ovsdbConnection, instanceIdentifierCodec);
    ovsdbDataTreeChangeListener = new OvsdbDataTreeChangeListener(db, cm, instanceIdentifierCodec);

    //Register listener for entityOnwership changes
    providerOwnershipChangeListener =
            new SouthboundPluginInstanceEntityOwnershipListener(this,this.entityOwnershipService);

    //register instance entity to get the ownership of the provider
    Entity instanceEntity = new Entity(ENTITY_TYPE, ENTITY_TYPE);
    try {
        Optional<EntityOwnershipState> ownershipStateOpt = entityOwnershipService.getOwnershipState(instanceEntity);
        registration = entityOwnershipService.registerCandidate(instanceEntity);
        if (ownershipStateOpt.isPresent()) {
            EntityOwnershipState ownershipState = ownershipStateOpt.get();
            if (ownershipState.hasOwner() && !ownershipState.isOwner()) {
                ovsdbConnection.registerConnectionListener(cm);
                ovsdbConnection.startOvsdbManager();
                LOG.info("*This* instance of OVSDB southbound provider is set as a SLAVE instance");
            }
        }
    } catch (CandidateAlreadyRegisteredException e) {
        LOG.warn("OVSDB Southbound Provider instance entity {} was already "
                + "registered for ownership", instanceEntity, e);
    }
}
 

import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; //导入依赖的package包/类
@Test
public void testInitWithClose() throws CandidateAlreadyRegisteredException {
    // Indicate that this is the owner
    when(entityOwnershipService.getOwnershipState(any(Entity.class))).thenReturn(
            Optional.of(new EntityOwnershipState(true, true)));

    try (SouthboundProvider southboundProvider = new SouthboundProvider(
            getDataBroker(),
            entityOwnershipService,
            Mockito.mock(OvsdbConnection.class),
            Mockito.mock(DOMSchemaService.class),
            Mockito.mock(BindingNormalizedNodeSerializer.class))) {

        // Initiate the session
        southboundProvider.init();

        // Verify that at least one listener was registered
        verify(entityOwnershipService, atLeastOnce()).registerListener(
                anyString(), any(EntityOwnershipListener.class));

        // Verify that a candidate was registered
        verify(entityOwnershipService).registerCandidate(any(Entity.class));

        //Close the session
        southboundProvider.close();
    }
}
 

import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; //导入依赖的package包/类
/**
 * Used by blueprint when starting the container.
 */
public void init() {
    LOG.info("HwvtepSouthboundProvider Session Initiated");
    txInvoker = new TransactionInvokerImpl(db);
    cm = new HwvtepConnectionManager(db, txInvoker, entityOwnershipService);
    hwvtepDTListener = new HwvtepDataChangeListener(db, cm);
    hwvtepReconciliationManager = new HwvtepReconciliationManager(db, cm);
    //Register listener for entityOnwership changes
    providerOwnershipChangeListener =
            new HwvtepsbPluginInstanceEntityOwnershipListener(this,this.entityOwnershipService);

    //register instance entity to get the ownership of the provider
    Entity instanceEntity = new Entity(ENTITY_TYPE, ENTITY_TYPE);
    try {
        Optional<EntityOwnershipState> ownershipStateOpt = entityOwnershipService.getOwnershipState(instanceEntity);
        registration = entityOwnershipService.registerCandidate(instanceEntity);
        if (ownershipStateOpt.isPresent()) {
            EntityOwnershipState ownershipState = ownershipStateOpt.get();
            if (ownershipState.hasOwner() && !ownershipState.isOwner()) {
                ovsdbConnection.registerConnectionListener(cm);
                ovsdbConnection.startOvsdbManager();
            }
        }
    } catch (CandidateAlreadyRegisteredException e) {
        LOG.warn("HWVTEP Southbound Provider instance entity {} was already "
                + "registered for ownership", instanceEntity, e);
    }
}
 

import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; //导入依赖的package包/类
private void registerEntityForOwnership(HwvtepConnectionInstance hwvtepConnectionInstance) {

        Entity candidateEntity = getEntityFromConnectionInstance(hwvtepConnectionInstance);
        entityConnectionMap.put(candidateEntity, hwvtepConnectionInstance);
        hwvtepConnectionInstance.setConnectedEntity(candidateEntity);

        try {
            EntityOwnershipCandidateRegistration registration =
                    entityOwnershipService.registerCandidate(candidateEntity);
            hwvtepConnectionInstance.setDeviceOwnershipCandidateRegistration(registration);
            LOG.info("HWVTEP entity {} is registered for ownership.", candidateEntity);

            //If entity already has owner, it won't get notification from EntityOwnershipService
            //so cache the connection instances.
            Optional<EntityOwnershipState> ownershipStateOpt =
                    entityOwnershipService.getOwnershipState(candidateEntity);
            if (ownershipStateOpt.isPresent()) {
                EntityOwnershipState ownershipState = ownershipStateOpt.get();
                if (ownershipState.hasOwner() && !ownershipState.isOwner()) {
                    if (getConnectionInstance(hwvtepConnectionInstance.getMDConnectionInfo()) != null) {
                        LOG.info("OVSDB entity {} is already owned by other southbound plugin "
                                + "instance, so *this* instance is NOT an OWNER of the device",
                                hwvtepConnectionInstance.getConnectionInfo());
                        putConnectionInstance(hwvtepConnectionInstance.getMDConnectionInfo(),hwvtepConnectionInstance);
                    }
                }
            }
        } catch (CandidateAlreadyRegisteredException e) {
            LOG.warn("OVSDB entity {} was already registered for ownership", candidateEntity, e);
        }

    }
 

import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; //导入依赖的package包/类
@Override
public Optional<EntityOwnershipState> getOwnershipState(Entity forEntity) {
    return toEntityOwnershipState(domService.getOwnershipState(toDOMEntity(forEntity)));
}
 

import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; //导入依赖的package包/类
@Override
public Optional<EntityOwnershipState> getOwnershipState(Entity forEntity) {
    return Optional.of(STATE);
}
 

import org.opendaylight.controller.md.sal.common.api.clustering.EntityOwnershipState; //导入依赖的package包/类
@Test
public void testHandleOwnershipChange() throws ReadFailedException {
    when(entityOwnershipService.getOwnershipState(any(Entity.class))).thenReturn(
            Optional.of(new EntityOwnershipState(false, true)));
    Entity entity = new Entity("ovsdb-southbound-provider", "ovsdb-southbound-provider");
    KeyedInstanceIdentifier<Topology, TopologyKey> topologyIid = InstanceIdentifier
            .create(NetworkTopology.class)
            .child(Topology.class, new TopologyKey(SouthboundConstants.OVSDB_TOPOLOGY_ID));

    try (SouthboundProvider southboundProvider = new SouthboundProvider(
            getDataBroker(),
            entityOwnershipService,
            Mockito.mock(OvsdbConnection.class),
            Mockito.mock(DOMSchemaService.class),
            Mockito.mock(BindingNormalizedNodeSerializer.class))) {

        southboundProvider.init();

        // At this point the OVSDB topology must not be present in either tree
        assertFalse(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION,
                topologyIid).checkedGet().isPresent());
        assertFalse(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL,
                topologyIid).checkedGet().isPresent());

        // Become owner
        southboundProvider.handleOwnershipChange(new EntityOwnershipChange(entity, false, true, true));

        // Now the OVSDB topology must be present in both trees
        assertTrue(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION,
                topologyIid).checkedGet().isPresent());
        assertTrue(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL,
                topologyIid).checkedGet().isPresent());

        // Verify idempotency
        southboundProvider.handleOwnershipChange(new EntityOwnershipChange(entity, false, true, true));

        // The OVSDB topology must be present in both trees
        assertTrue(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.CONFIGURATION,
                topologyIid).checkedGet().isPresent());
        assertTrue(getDataBroker().newReadOnlyTransaction().read(LogicalDatastoreType.OPERATIONAL,
                topologyIid).checkedGet().isPresent());
    }
}