Java SyncException类代码示例

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
@Override
public List<Versioned<byte[]>> get(ByteArray key) throws SyncException {
    StoreUtils.assertValidKey(key);
    GetRequestMessage grm = new GetRequestMessage();

    AsyncMessageHeader header = new AsyncMessageHeader();
    header.setTransactionId(syncManager.getTransactionId());
    grm.setHeader(header);

    grm.setKey(key.get());
    grm.setStoreName(storeName);
    
    SyncMessage bsm = new SyncMessage(MessageType.GET_REQUEST);
    bsm.setGetRequest(grm);

    SyncReply reply = getReply(header.getTransactionId(), bsm);

    return reply.getValues();
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
@Override
public IVersion put(K key, V value) throws SyncException {
    List<IVersion> versions = getVersions(key);
    Versioned<V> versioned;
    if(versions.isEmpty())
        versioned = Versioned.value(value, new VectorClock());
    else if(versions.size() == 1)
        versioned = Versioned.value(value, versions.get(0));
    else {
        versioned = get(key, null);
        if(versioned == null)
            versioned = Versioned.value(value, new VectorClock());
        else
            versioned.setValue(value);
    }
    return put(key, versioned);
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
private void init(List<Node> nodes, short thisNodeId,
                  AuthScheme authScheme,
                  String keyStorePath, 
                  String keyStorePassword)
        throws SyncException {
    for (Node n : nodes) {
        addNode(n);
    }
    thisNode = getNode(thisNodeId);
    if (thisNode == null) {
        throw new SyncException("Cannot set thisNode " +
                "node: No node with ID " + thisNodeId);
    }
    this.authScheme = authScheme;
    if (this.authScheme == null) 
        this.authScheme = AuthScheme.NO_AUTH;
    this.keyStorePath = keyStorePath;
    this.keyStorePassword = keyStorePassword;
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
private byte[] getValueBytes(V value) throws SyncException {
    try {
        byte[] v = null;
        if (valueAsTree)
            v = mapper.writeValueAsBytes(value);
        else
            v = valueWriter.writeValueAsBytes(value);
        
        if (logger.isTraceEnabled()) {
            logger.trace("Converted value {} to {}", 
                         value, Arrays.toString(v));
        }
        return v;
    } catch (Exception e) {
        throw new SerializationException(e);
    }
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
@Override
public void put(ByteArray key, Versioned<byte[]> value) 
        throws SyncException {
    StoreUtils.assertValidKey(key);
    PutRequestMessage prm = new PutRequestMessage();

    AsyncMessageHeader header = new AsyncMessageHeader();
    header.setTransactionId(syncManager.getTransactionId());
    prm.setHeader(header);
    prm.setVersionedValue(TProtocolUtil.getTVersionedValue(value));
    prm.setKey(key.get());
    prm.setStoreName(storeName);
    
    SyncMessage bsm = new SyncMessage(MessageType.PUT_REQUEST);
    bsm.setPutRequest(prm);
    
    getReply(header.getTransactionId(), bsm);
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
/**
 * Add a new node to the cluster
 * @param node the {@link Node} to add
 * @throws SyncException if the node already exists
 */
private void addNode(Node node) throws SyncException {
    Short nodeId = node.getNodeId();
    if (allNodes.get(nodeId) != null) {
        throw new SyncException("Error adding node " + node +
                ": a node with that ID already exists");
    }
    allNodes.put(nodeId, node);

    Short domainId = node.getDomainId();
    List<Node> localDomain = localDomains.get(domainId);
    if (localDomain == null) {
        localDomains.put(domainId,
                         localDomain = new ArrayList<Node>());
    }
    localDomain.add(node);
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
@Override
public void init(SyncManager syncManager, FloodlightModuleContext context) 
        throws SyncException {
    this.syncManager = syncManager;
    threadPool = context.getServiceImpl(IThreadPoolService.class);
    syncManager.registerPersistentStore(SYSTEM_NODE_STORE, Scope.GLOBAL);
    syncManager.registerPersistentStore(SYSTEM_UNSYNC_STORE, 
                                        Scope.UNSYNCHRONIZED);
    this.nodeStoreClient = 
            syncManager.getStoreClient(SYSTEM_NODE_STORE, 
                                       Short.class, Node.class);
    this.nodeStoreClient.addStoreListener(new ShortListener());
    this.unsyncStoreClient = 
            syncManager.getStoreClient(SYSTEM_UNSYNC_STORE, 
                                       String.class, String.class);
    this.unsyncStoreClient.addStoreListener(new StringListener());
    
    config = context.getConfigParams(syncManager);
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
@Override
protected void handleError(ErrorMessage error, Channel channel) {            
    ErrorType errType = ErrorType.GENERIC;
    for (ErrorType e : ErrorType.values()) {
        if (e.getValue() == error.getError().getErrorCode()) {
            errType = e;
            break;
        }
    }
    SyncException ex = 
            SyncException.newInstance(errType, 
                                      error.getError().getMessage(), 
                                      null);
    if (ChannelState.CONNECTED.equals(channelState) ||
        ChannelState.OPEN.equals(channelState) ||
        ErrorType.AUTH.equals(errType)) {
        syncManager.channelDisconnected(ex);
        channel.close();
    } else {
        SyncReply reply = new SyncReply(null, null, false, ex, 0);
        syncManager.dispatchReply(error.getHeader().getTransactionId(), 
                                  reply);
    }
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
@Override
@LogMessageDoc(level="INFO",
    message="Cluster not yet configured; using fallback " + 
            "local configuration",
    explanation="No other nodes are known")
public ClusterConfig getConfig() throws SyncException {
    if (!warned) {
        logger.info("Cluster not yet configured; using fallback local " + 
                    "configuration");
        warned = true;
    }
    return new ClusterConfig(Collections.
                             singletonList(new Node("localhost",
                                                    syncPort,
                                                    Short.MAX_VALUE,
                                                    Short.MAX_VALUE)),
                                                    Short.MAX_VALUE,
                                                    "localhost",
                                                    authScheme,
                                                    keyStorePath,
                                                    keyStorePassword);
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
public RemoteIterator() {
    CursorRequestMessage crm = getCRM();
    crm.setStoreName(storeName);
    SyncMessage bsm = new SyncMessage(MessageType.CURSOR_REQUEST);
    bsm.setCursorRequest(crm);
    SyncReply reply;
    try {
        reply = getReply(crm.getHeader().getTransactionId(), 
                         bsm);
    } catch (SyncException e) {
        throw new SyncRuntimeException(e);
    }
    this.cursorId = reply.getIntValue();
    if (reply.getKeyedValues() != null)
        currentChunk = reply.getKeyedValues().iterator();
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
private Iterator<KeyedValues> getChunk() {
    CursorRequestMessage crm = getCRM();
    crm.setCursorId(cursorId);
    SyncMessage bsm = new SyncMessage(MessageType.CURSOR_REQUEST);
    bsm.setCursorRequest(crm);

    SyncReply reply;
    try {
        reply = getReply(crm.getHeader().getTransactionId(), 
                                      bsm);
    } catch (SyncException e) {
        throw new SyncRuntimeException(e);
    }
    if (reply.getKeyedValues() == null || 
        reply.getKeyedValues().size() == 0) return null;

    return reply.getKeyedValues().iterator();
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
protected void ensureConnected() {
    if (!ready) {
        for (int i = 0; i < 2; i++) {
            synchronized (this) {
                connectionGeneration += 1;
                if (connect(hostname, port))
                    return;
            }
            try {
                Thread.sleep(1000);
            } catch (Exception e) {}
        }
        if (channel == null) 
            throw new SyncRuntimeException(new SyncException("Failed to establish connection"));
    }
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
@Override
public void cleanupTask() throws SyncException {
    Connection dbConnection = null;
    PreparedStatement stmt = null;
    try {
        dbConnection = getConnection();
        dbConnection.setAutoCommit(true);
        stmt = dbConnection.prepareStatement(getSql(SELECT_ALL));
        ResultSet rs = stmt.executeQuery();
        while (rs.next()) {
            List<Versioned<byte[]>> items = getVersionedList(rs);
            if (StoreUtils.canDelete(items, tombstoneDeletion)) {
                doClearTombstone(rs.getString("datakey"));
            }
        }                
    } catch (Exception e) {
        logger.error("Failed to delete key", e);
    } finally {
        cleanupSQL(dbConnection, stmt);
    }
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
@Override
public List<Versioned<byte[]>> get(ByteArray key) throws SyncException {
    StoreUtils.assertValidKey(key);
    Connection dbConnection = null;
    PreparedStatement stmt = null;
    try {
        dbConnection = getConnection();
        stmt = dbConnection.prepareStatement(getSql(SELECT_KEY));
        return doSelect(stmt, getKeyAsString(key));

    } catch (Exception e) {
        throw new PersistException("Could not retrieve key" +
                " from database",
                e);
    } finally {
        cleanupSQL(dbConnection, stmt);
    }
}
 

import org.sdnplatform.sync.error.SyncException; //导入依赖的package包/类
private Node setupLocalNode(Node localNode, Short localNodeId,
                            boolean firstNode) 
        throws SyncException {
    short nodeId = -1;
    short domainId = -1;
    if (localNode != null) {
        nodeId = localNode.getNodeId();
        domainId = localNode.getDomainId();
    } else if (localNodeId != null) {
        domainId = nodeId = localNodeId;
    } else if (firstNode) {
        domainId = nodeId = 
                (short)(new Random().nextInt(Short.MAX_VALUE));
    }
    Node n = getLocalNode(nodeId, domainId);
    return n;
}