Java IClosableIterator.hasNext方法代码示例

import org.sdnplatform.sync.IClosableIterator; //导入方法依赖的package包/类
@Override
public boolean execute(String[] tokens, String line) throws Exception {
    if (!checkStoreSettings()) return false;

    IClosableIterator<Entry<JsonNode, Versioned<JsonNode>>> iter = 
            storeClient.entries();
    try {
        while (iter.hasNext()) {
            Entry<JsonNode, Versioned<JsonNode>> e = iter.next();
            display(e.getKey(), e.getValue());
        }
    } finally {
        iter.close();
    }
    return false;
}
 

import org.sdnplatform.sync.IClosableIterator; //导入方法依赖的package包/类
public static <K, V> IClosableIterator<K>
    keys(final IClosableIterator<Entry<K, V>> values) {
    return new IClosableIterator<K>() {

        public void close() {
            values.close();
        }

        public boolean hasNext() {
            return values.hasNext();
        }

        public K next() {
            Entry<K, V> value = values.next();
            if(value == null)
                return null;
            return value.getKey();
        }

        public void remove() {
            values.remove();
        }

    };
}
 

import org.sdnplatform.sync.IClosableIterator; //导入方法依赖的package包/类
private List<DeviceSyncRepresentation> getEntriesFromStore()
		throws Exception {
	List<DeviceSyncRepresentation> entries =
			new ArrayList<DeviceSyncRepresentation>();
	IClosableIterator<Entry<String, Versioned<DeviceSyncRepresentation>>> iter =
			storeClient.entries();
	try {
		while(iter.hasNext()) {
			Entry<String, Versioned<DeviceSyncRepresentation>> entry =
					iter.next();
			DeviceSyncRepresentation dsr = entry.getValue().getValue();
			if (dsr != null)
				assertEquals(entry.getKey(), dsr.getKey());
			entries.add(dsr);
		}
	} finally {
		if (iter != null)
			iter.close();
	}
	return entries;
}
 

import org.sdnplatform.sync.IClosableIterator; //导入方法依赖的package包/类
/**
 * Synchronously transition from SLAVE to MASTER. By iterating through
 * the store and learning all devices from the store
 */
private void goToMaster() {
 if (logger.isDebugEnabled()) {
	 logger.debug("Transitioning to MASTER role");
 }
 cntTransitionToMaster.increment();
 IClosableIterator<Map.Entry<String,Versioned<DeviceSyncRepresentation>>>
 iter = null;
 try {
	 iter = storeClient.entries();
 } catch (SyncException e) {
	 cntSyncException.increment();
	 logger.error("Failed to read devices from sync store", e);
	 return;
 }
 try {
	 while(iter.hasNext()) {
		 Versioned<DeviceSyncRepresentation> versionedDevice =
				 iter.next().getValue();
		 DeviceSyncRepresentation storedDevice =
				 versionedDevice.getValue();
		 if (storedDevice == null)
			 continue;
		 cntDevicesFromStore.increment();
		 for(SyncEntity se: storedDevice.getEntities()) {
			 learnDeviceByEntity(se.asEntity());
		 }
	 }
 } finally {
	 if (iter != null)
		 iter.close();
 }
 storeConsolidateTask.reschedule(initialSyncStoreConsolidateMs,
		 TimeUnit.MILLISECONDS);
}
 

import org.sdnplatform.sync.IClosableIterator; //导入方法依赖的package包/类
@Test
public void testIterator() throws Exception {
    AbstractSyncManager sync = syncManagers[0];
    IStoreClient<Key, TBean> testClient =
            sync.getStoreClient("local", Key.class, TBean.class);
    
    HashMap<Key, TBean> testMap = new HashMap<Key, TBean>();
    for (int i = 0; i < 100; i++) {
        Key k = new Key("com.bigswitch.bigsync.internal", "test" + i);
        TBean tb = new TBean("value", i);
        testMap.put(k, tb);
        testClient.put(k, tb);
    }
    
    IClosableIterator<Entry<Key, Versioned<TBean>>> iter = 
            testClient.entries();
    int size = 0;
    try {
        while (iter.hasNext()) {
            Entry<Key, Versioned<TBean>> e = iter.next();
            assertEquals(testMap.get(e.getKey()), e.getValue().getValue());
            size += 1;
        }
    } finally {
        iter.close();
    }
    assertEquals(testMap.size(), size);
}
 

import org.sdnplatform.sync.IClosableIterator; //导入方法依赖的package包/类
public void testGetNoEntries() {
    IClosableIterator<Entry<ByteArray, List<Versioned<byte[]>>>> it = null;
    try {
        IStorageEngine<ByteArray, byte[]> engine = getStorageEngine();
        it = engine.entries();
        while(it.hasNext())
            fail("There shouldn't be any entries in this store.");
    } finally {
        if(it != null)
            it.close();
    }
}
 

import org.sdnplatform.sync.IClosableIterator; //导入方法依赖的package包/类
@Test
public void testGetNoKeys() {
    IClosableIterator<ByteArray> it = null;
    try {
        IStorageEngine<ByteArray, byte[]> engine = getStorageEngine();
        it = engine.keys();
        while(it.hasNext())
            fail("There shouldn't be any entries in this store.");
    } finally {
        if(it != null)
            it.close();
    }
}
 

import org.sdnplatform.sync.IClosableIterator; //导入方法依赖的package包/类
@Test
public void testTruncate() throws Exception {
    IStorageEngine<ByteArray, byte[]> engine = getStorageEngine();
    Versioned<byte[]> v1 = new Versioned<byte[]>(new byte[] { 1 });
    Versioned<byte[]> v2 = new Versioned<byte[]>(new byte[] { 2 });
    Versioned<byte[]> v3 = new Versioned<byte[]>(new byte[] { 3 });
    ByteArray key1 = new ByteArray((byte) 3);
    ByteArray key2 = new ByteArray((byte) 4);
    ByteArray key3 = new ByteArray((byte) 5);

    engine.put(key1, v1);
    engine.put(key2, v2);
    engine.put(key3, v3);
    engine.truncate();

    IClosableIterator<Entry<ByteArray, List<Versioned<byte[]>>>> it = null;
    try {
        it = engine.entries();
        while(it.hasNext()) {
            fail("There shouldn't be any entries in this store.");
        }
    } finally {
        if(it != null) {
            it.close();
        }
    }
}
 

import org.sdnplatform.sync.IClosableIterator; //导入方法依赖的package包/类
/**
 * Synchronously transition from SLAVE to MASTER. By iterating through
 * the store and learning all devices from the store
 */
private void goToMaster() {
    if (logger.isDebugEnabled()) {
        logger.debug("Transitioning to MASTER role");
    }
    cntTransitionToMaster.updateCounterWithFlush();
    IClosableIterator<Map.Entry<String,Versioned<DeviceSyncRepresentation>>>
            iter = null;
    try {
        iter = storeClient.entries();
    } catch (SyncException e) {
        cntSyncException.updateCounterWithFlush();
        logger.error("Failed to read devices from sync store", e);
        return;
    }
    try {
        while(iter.hasNext()) {
            Versioned<DeviceSyncRepresentation> versionedDevice =
                    iter.next().getValue();
            DeviceSyncRepresentation storedDevice =
                    versionedDevice.getValue();
            if (storedDevice == null)
                continue;
            cntDevicesFromStore.updateCounterWithFlush();
            for(SyncEntity se: storedDevice.getEntities()) {
                learnDeviceByEntity(se.asEntity());
            }
        }
    } finally {
        if (iter != null)
            iter.close();
    }
    storeConsolidateTask.reschedule(initialSyncStoreConsolidateMs,
                                    TimeUnit.MILLISECONDS);
}
 

import org.sdnplatform.sync.IClosableIterator; //导入方法依赖的package包/类
/**
 * Perform a synchronization with the node specified
 */
public void antientropy(Node node) {
	if (!rpcService.isConnected(node.getNodeId())) return;

	logger.info("[{}->{}] Synchronizing local state to remote node",
			getLocalNodeId(), node.getNodeId());

	for (SynchronizingStorageEngine store : storeRegistry.values()) {
		if (Scope.LOCAL.equals(store.getScope())) {
			if (node.getDomainId() !=
					getClusterConfig().getNode().getDomainId())
				continue;
		} else if (Scope.UNSYNCHRONIZED.equals(store.getScope())) {
			continue;
		}

		IClosableIterator<Entry<ByteArray,
		List<Versioned<byte[]>>>> entries =
		store.entries();
		try {
			SyncMessage bsm =
					TProtocolUtil.getTSyncOfferMessage(store.getName(),
							store.getScope(),
							store.isPersistent());
			int count = 0;
			while (entries.hasNext()) {
				if (!rpcService.isConnected(node.getNodeId())) return;

				Entry<ByteArray, List<Versioned<byte[]>>> pair =
						entries.next();
				KeyedVersions kv =
						TProtocolUtil.getTKeyedVersions(pair.getKey(),
								pair.getValue());
				bsm.getSyncOffer().addToVersions(kv);
				count += 1;
				if (count >= 50) {
					sendSyncOffer(node.getNodeId(), bsm);
					// realloc sync message - it is still queued up by netty!
					bsm = TProtocolUtil.getTSyncOfferMessage(store.getName(),
							store.getScope(),
							store.isPersistent());
					count = 0;
				}
			}
			sendSyncOffer(node.getNodeId(), bsm);
		} catch (InterruptedException e) {
			// This can't really happen
			throw new RuntimeException(e);
		} finally {
			entries.close();
		}
	}
}
 

import org.sdnplatform.sync.IClosableIterator; //导入方法依赖的package包/类
/**
 * Perform a synchronization with the node specified
 */
@LogMessageDoc(level="INFO",
               message="[{id}->{id}] Synchronizing local state to remote node",
               explanation="Normal state resynchronization is occurring")
public void antientropy(Node node) {
    if (!rpcService.isConnected(node.getNodeId())) return;

    logger.info("[{}->{}] Synchronizing local state to remote node",
                getLocalNodeId(), node.getNodeId());

    for (SynchronizingStorageEngine store : storeRegistry.values()) {
        if (Scope.LOCAL.equals(store.getScope())) {
            if (node.getDomainId() !=
                    getClusterConfig().getNode().getDomainId())
                continue;
        } else if (Scope.UNSYNCHRONIZED.equals(store.getScope())) {
            continue;
        }

        IClosableIterator<Entry<ByteArray,
                              List<Versioned<byte[]>>>> entries =
                store.entries();
        try {
            SyncMessage bsm =
                    TProtocolUtil.getTSyncOfferMessage(store.getName(),
                                                       store.getScope(),
                                                       store.isPersistent());
            int count = 0;
            while (entries.hasNext()) {
                if (!rpcService.isConnected(node.getNodeId())) return;

                Entry<ByteArray, List<Versioned<byte[]>>> pair =
                        entries.next();
                KeyedVersions kv =
                        TProtocolUtil.getTKeyedVersions(pair.getKey(),
                                                        pair.getValue());
                bsm.getSyncOffer().addToVersions(kv);
                count += 1;
                if (count >= 50) {
                    sendSyncOffer(node.getNodeId(), bsm);
                    bsm.getSyncOffer().unsetVersions();
                    count = 0;
                }
            }
            sendSyncOffer(node.getNodeId(), bsm);
        } catch (InterruptedException e) {
            // This can't really happen
            throw new RuntimeException(e);
        } finally {
            entries.close();
        }
    }
}