Java OpCode.create方法代码示例

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
/**
 * Simulates ZOOKEEPER-1069 and verifies that flush() before padLogFile
 * fixes it.
 */
@Test
public void testPad() throws Exception {
    File tmpDir = ClientBase.createTmpDir();
    FileTxnLog txnLog = new FileTxnLog(tmpDir);
    TxnHeader txnHeader = new TxnHeader(0xabcd, 0x123, 0x123,
          Time.currentElapsedTime(), OpCode.create);
    Record txn = new CreateTxn("/Test", new byte[0], null, false, 1);
    txnLog.append(txnHeader, txn);
    FileInputStream in = new FileInputStream(tmpDir.getPath() + "/log." +
          Long.toHexString(txnHeader.getZxid()));
    BinaryInputArchive ia  = BinaryInputArchive.getArchive(in);
    FileHeader header = new FileHeader();
    header.deserialize(ia, "fileheader");
    LOG.info("Received magic : " + header.getMagic() +
          " Expected : " + FileTxnLog.TXNLOG_MAGIC);
    Assert.assertTrue("Missing magic number ",
          header.getMagic() == FileTxnLog.TXNLOG_MAGIC);
}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
/**
 * Simulates ZOOKEEPER-1069 and verifies that flush() before padLogFile
 * fixes it.
 */
@Test
public void testPad() throws Exception {
    File tmpDir = ClientBase.createTmpDir();
    FileTxnLog txnLog = new FileTxnLog(tmpDir);
    TxnHeader txnHeader = new TxnHeader(0xabcd, 0x123, 0x123,
          System.currentTimeMillis(), OpCode.create);
    Record txn = new CreateTxn("/Test", new byte[0], null, false, 1);
    txnLog.append(txnHeader, txn);
    FileInputStream in = new FileInputStream(tmpDir.getPath() + "/log." +
          Long.toHexString(txnHeader.getZxid()));
    BinaryInputArchive ia  = BinaryInputArchive.getArchive(in);
    FileHeader header = new FileHeader();
    header.deserialize(ia, "fileheader");
    LOG.info("Received magic : " + header.getMagic() +
          " Expected : " + FileTxnLog.TXNLOG_MAGIC);
    Assert.assertTrue("Missing magic number ",
          header.getMagic() == FileTxnLog.TXNLOG_MAGIC);
}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
protected boolean needCommit(Request request) {
    switch (request.type) {
        case OpCode.create:
        case OpCode.create2:
        case OpCode.createContainer:
        case OpCode.delete:
        case OpCode.deleteContainer:
        case OpCode.setData:
        case OpCode.reconfig:
        case OpCode.multi:
        case OpCode.setACL:
            return true;
        case OpCode.sync:
            return matchSyncs;    
        case OpCode.createSession:
        case OpCode.closeSession:
            return !request.isLocalSession();
        default:
            return false;
    }
}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
static String op2String(int op) {
    switch (op) {
    case OpCode.notification:
        return "notification";
    case OpCode.create:
        return "create";
    case OpCode.delete:
        return "delete";
    case OpCode.exists:
        return "exists";
    case OpCode.getData:
        return "getDate";
    case OpCode.setData:
        return "setData";
    case OpCode.multi:
        return "multi";
    case OpCode.getACL:
        return "getACL";
    case OpCode.setACL:
        return "setACL";
    case OpCode.getChildren:
        return "getChildren";
    case OpCode.getChildren2:
        return "getChildren2";
    case OpCode.ping:
        return "ping";
    case OpCode.createSession:
        return "createSession";
    case OpCode.closeSession:
        return "closeSession";
    case OpCode.error:
        return "error";
    default:
        return "unknown " + op;
    }
}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
/**
 * is the packet type a valid packet in zookeeper
 * 
 * @param type
 *                the type of the packet
 * @return true if a valid packet, false if not
 */
static boolean isValid(int type) {
    // make sure this is always synchronized with Zoodefs!!
    switch (type) {
    case OpCode.notification:
        return false;
    case OpCode.create:
    case OpCode.delete:
    case OpCode.createSession:
    case OpCode.exists:
    case OpCode.getData:
    case OpCode.check:
    case OpCode.multi:
    case OpCode.setData:
    case OpCode.sync:
    case OpCode.getACL:
    case OpCode.setACL:
    case OpCode.getChildren:
    case OpCode.getChildren2:
    case OpCode.ping:
    case OpCode.closeSession:
    case OpCode.setWatches:
        return true;
    default:
        return false;
    }
}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
@Test
public void testPRequest() throws Exception {
    pLatch = new CountDownLatch(1);
    processor = new PrepRequestProcessor(zks, new MyRequestProcessor());
    Request foo = new Request(null, 1l, 1, OpCode.create, ByteBuffer.allocate(3), null);
    processor.pRequest(foo);

    Assert.assertEquals("Request should have marshalling error", new ErrorTxn(KeeperException.Code.MARSHALLINGERROR.intValue()),
            outcome.txn);
    Assert.assertTrue("request hasn't been processed in chain", pLatch.await(5, TimeUnit.SECONDS));
}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
/**
 * When local session is enabled, leader will allow persistent node
 * to be create for unknown session
 */
@Test
public void testCreatePersistent() throws Exception {
    qu.enableLocalSession(true);
    qu.startAll();

    QuorumPeer leader = qu.getLeaderQuorumPeer();

    ZooKeeper zk = ClientBase.createZKClient(qu.getConnectString(leader));

    CreateRequest createRequest = new CreateRequest("/success",
            new byte[0], Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT.toFlag());
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    BinaryOutputArchive boa = BinaryOutputArchive.getArchive(baos);
    createRequest.serialize(boa, "request");
    ByteBuffer bb = ByteBuffer.wrap(baos.toByteArray());

    // Mimic sessionId generated by follower's local session tracker
    long sid = qu.getFollowerQuorumPeers().get(0).getActiveServer()
            .getServerId();
    long locallSession = (sid << 56) + 1;

    LOG.info("Local session Id: " + Long.toHexString(locallSession));

    Request request = new Request(null, locallSession, 0, OpCode.create,
            bb, new ArrayList<Id>());

    // Submit request directly to leader
    leader.getActiveServer().submitRequest(request);

    // Make sure that previous request is finished
    zk.create("/ok", new byte[0], Ids.OPEN_ACL_UNSAFE,
            CreateMode.PERSISTENT);

    Stat stat = zk.exists("/success", null);
    Assert.assertTrue("Request from local sesson failed", stat != null);

}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
/**
 * is the packet type a valid packet in zookeeper
 *
 * @param type
 *                the type of the packet
 * @return true if a valid packet, false if not
 */
static boolean isValid(int type) {
    // make sure this is always synchronized with Zoodefs!!
    switch (type) {
    case OpCode.notification:
        return false;
    case OpCode.check:
    case OpCode.closeSession:
    case OpCode.create:
    case OpCode.create2:
    case OpCode.createTTL:
    case OpCode.createContainer:
    case OpCode.createSession:
    case OpCode.delete:
    case OpCode.deleteContainer:
    case OpCode.exists:
    case OpCode.getACL:
    case OpCode.getChildren:
    case OpCode.getChildren2:
    case OpCode.getData:
    case OpCode.multi:
    case OpCode.ping:
    case OpCode.reconfig:
    case OpCode.setACL:
    case OpCode.setData:
    case OpCode.setWatches:
    case OpCode.sync:
    case OpCode.checkWatches:
    case OpCode.removeWatches:
        return true;
    default:
        return false;
    }
}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
public boolean isQuorum() {
    switch (this.type) {
    case OpCode.exists:
    case OpCode.getACL:
    case OpCode.getChildren:
    case OpCode.getChildren2:
    case OpCode.getData:
        return false;
    case OpCode.create:
    case OpCode.create2:
    case OpCode.createTTL:
    case OpCode.createContainer:
    case OpCode.error:
    case OpCode.delete:
    case OpCode.deleteContainer:
    case OpCode.setACL:
    case OpCode.setData:
    case OpCode.check:
    case OpCode.multi:
    case OpCode.reconfig:
        return true;
    case OpCode.closeSession:
    case OpCode.createSession:
        return !this.isLocalSession;
    default:
        return false;
    }
}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
public void sendWriteRequest() throws Exception {
    ByteArrayOutputStream boas = new ByteArrayOutputStream();
    BinaryOutputArchive boa = BinaryOutputArchive.getArchive(boas);
    CreateRequest createReq = new CreateRequest(
        "/session" + Long.toHexString(sessionId) + "-" + (++nodeId),
        new byte[0], Ids.OPEN_ACL_UNSAFE, 1);
    createReq.serialize(boa, "request");
    ByteBuffer bb = ByteBuffer.wrap(boas.toByteArray());
    Request req = new Request(null, sessionId, ++cxid, OpCode.create,
                              bb, new ArrayList<Id>());
    zks.getFirstProcessor().processRequest(req);

}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
public boolean isQuorum() {
    switch (this.type) {
    case OpCode.exists:
    case OpCode.getACL:
    case OpCode.getChildren:
    case OpCode.getChildren2:
    case OpCode.getData:
        return false;
    case OpCode.create:
    case OpCode.create2:
    case OpCode.createContainer:
    case OpCode.error:
    case OpCode.delete:
    case OpCode.deleteContainer:
    case OpCode.setACL:
    case OpCode.setData:
    case OpCode.check:
    case OpCode.multi:
    case OpCode.reconfig:
        return true;
    case OpCode.closeSession:
    case OpCode.createSession:
        return !this.isLocalSession;
    default:
        return false;
    }
}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
public Request checkUpgradeSession(Request request)
        throws IOException, KeeperException {
    // If this is a request for a local session and it is to
    // create an ephemeral node, then upgrade the session and return
    // a new session request for the leader.
    // This is called by the request processor thread (either follower
    // or observer request processor), which is unique to a learner.
    // So will not be called concurrently by two threads.
    if (request.type != OpCode.create ||
        !upgradeableSessionTracker.isLocalSession(request.sessionId)) {
        return null;
    }
    CreateRequest createRequest = new CreateRequest();
    request.request.rewind();
    ByteBufferInputStream.byteBuffer2Record(request.request, createRequest);
    request.request.rewind();
    CreateMode createMode = CreateMode.fromFlag(createRequest.getFlags());
    if (!createMode.isEphemeral()) {
        return null;
    }
    // Uh oh.  We need to upgrade before we can proceed.
    if (!self.isLocalSessionsUpgradingEnabled()) {
        throw new KeeperException.EphemeralOnLocalSessionException();
    }

    return makeUpgradeRequest(request.sessionId);
}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
static String op2String(int op) {
    switch (op) {
    case OpCode.notification:
        return "notification";
    case OpCode.create:
        return "create";
    case OpCode.setWatches:
        return "setWatches";
    case OpCode.delete:
        return "delete";
    case OpCode.exists:
        return "exists";
    case OpCode.getData:
        return "getData";
    case OpCode.setData:
        return "setData";
    case OpCode.sync:
          return "sync:";
    case OpCode.getACL:
        return "getACL";
    case OpCode.setACL:
        return "setACL";
    case OpCode.getChildren:
        return "getChildren";
    case OpCode.getChildren2:
        return "getChildren2";
    case OpCode.ping:
        return "ping";
    case OpCode.createSession:
        return "createSession";
    case OpCode.closeSession:
        return "closeSession";
    case OpCode.error:
        return "error";
    default:
        return "unknown " + op;
    }
}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
@Override
public void run() {
    try {
        while (!finished) {
            Request request = queuedRequests.take();
            if (LOG.isTraceEnabled()) {
                ZooTrace.logRequest(LOG, ZooTrace.CLIENT_REQUEST_TRACE_MASK,
                        'F', request, "");
            }
            if (request == Request.requestOfDeath) {
                break;
            }
            // We want to queue the request to be processed before we submit
            // the request to the leader so that we are ready to receive
            // the response
            nextProcessor.processRequest(request);
            
            // We now ship the request to the leader. As with all
            // other quorum operations, sync also follows this code
            // path, but different from others, we need to keep track
            // of the sync operations this follower has pending, so we
            // add it to pendingSyncs.
            switch (request.type) {
            case OpCode.sync:
                zks.pendingSyncs.add(request);
                zks.getFollower().request(request);
                break;
            case OpCode.create:
            case OpCode.delete:
            case OpCode.setData:
            case OpCode.setACL:
            case OpCode.createSession:
            case OpCode.closeSession:
            case OpCode.multi:
                zks.getFollower().request(request);
                break;
            }
        }
    } catch (Exception e) {
        handleException(this.getName(), e);
    }
    LOG.info("FollowerRequestProcessor exited loop!");
}
 

import org.apache.zookeeper.ZooDefs.OpCode; //导入方法依赖的package包/类
@Override
public void run() {
    try {
        while (!finished) {
            Request request = queuedRequests.take();
            if (LOG.isTraceEnabled()) {
                ZooTrace.logRequest(LOG, ZooTrace.CLIENT_REQUEST_TRACE_MASK,
                        'F', request, "");
            }
            if (request == Request.requestOfDeath) {
                break;
            }
            // We want to queue the request to be processed before we submit
            // the request to the leader so that we are ready to receive
            // the response
            nextProcessor.processRequest(request);
            
            // We now ship the request to the leader. As with all
            // other quorum operations, sync also follows this code
            // path, but different from others, we need to keep track
            // of the sync operations this Observer has pending, so we
            // add it to pendingSyncs.
            switch (request.type) {
            case OpCode.sync:
                zks.pendingSyncs.add(request);
                zks.getObserver().request(request);
                break;
            case OpCode.create:
            case OpCode.delete:
            case OpCode.setData:
            case OpCode.setACL:
            case OpCode.createSession:
            case OpCode.closeSession:
            case OpCode.multi:
                zks.getObserver().request(request);
                break;
            }
        }
    } catch (Exception e) {
        handleException(this.getName(), e);
    }
    LOG.info("ObserverRequestProcessor exited loop!");
}