jam2in / arcus-java-client Goto Github PK

    protected void optimize() {
        // make sure there are at least two get operations in a row before
        // attempting to optimize them.
        if(writeQ.peek() instanceof GetOperation) {
            optimizedOp=writeQ.remove();
            if(writeQ.peek() instanceof GetOperation) {
                OptimizedGetImpl og=new OptimizedGetImpl(
                        (GetOperation)optimizedOp);
                optimizedOp=og;

                while(writeQ.peek() instanceof GetOperation) {
                    GetOperationImpl o=(GetOperationImpl) writeQ.remove();
                    if(!o.isCancelled()) {
                        og.addOperation(o);
                    }
                }

                // Initialize the new mega get
                optimizedOp.initialize();
                assert optimizedOp.getState() == OperationState.WRITING;
                ProxyCallback pcb=(ProxyCallback) og.getCallback();
                getLogger().debug("Set up %s with %s keys and %s callbacks",
                    this, pcb.numKeys(), pcb.numCallbacks());
            }
        }
    }

creationTime 6 
maxInactiveTime 2 %^&$(인코딩 실패)
lastAaccessedTime 6 %^&$(인코딩 실패)

    public final void fillWriteBuffer(boolean shouldOptimize) {
        if(toWrite == 0 && readQ.remainingCapacity() > 0) {
            getWbuf().clear();
            Operation o=getCurrentWriteOp();
            while(o != null && toWrite < getWbuf().capacity()) {
                assert o.getState() == OperationState.WRITING;
                // This isn't the most optimal way to do this, but it hints
                // at a larger design problem that may need to be taken care
                // if in the bowels of the client.
                // In practice, readQ should be small, however.
                if(!readQ.contains(o)) {
                    readQ.add(o);
                }

                ByteBuffer obuf=o.getBuffer();
                assert obuf != null : "Didn't get a write buffer from " + o;
                int bytesToCopy=Math.min(getWbuf().remaining(),
                        obuf.remaining());
                byte b[]=new byte[bytesToCopy];
                obuf.get(b);
                getWbuf().put(b);
                getLogger().debug("After copying stuff from %s: %s",
                        o, getWbuf());
                if(!o.getBuffer().hasRemaining()) {
                    o.writeComplete();
                    transitionWriteItem();

                    preparePending();
                    if(shouldOptimize) {
                        optimize();
                    }

                    o=getCurrentWriteOp();
                }
                toWrite += bytesToCopy;
            }
            getWbuf().flip();
            assert toWrite <= getWbuf().capacity()
                : "toWrite exceeded capacity: " + this;
            assert toWrite == getWbuf().remaining()
                : "Expected " + toWrite + " remaining, got "
                + getWbuf().remaining();
        } else {
            getLogger().debug("Buffer is full, skipping");
        }
    }

2016-08-17 11:12:27.359 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR type=kv
2016-08-17 11:12:27.360 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR flags=0
2016-08-17 11:12:27.360 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR expiretime=0
2016-08-17 11:12:27.361 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR type=kv
2016-08-17 11:12:27.362 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR flags=0
2016-08-17 11:12:27.362 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR expiretime=0
2016-08-17 11:12:27.365 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR type=kv
2016-08-17 11:12:27.365 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR flags=0
2016-08-17 11:12:27.366 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR expiretime=0
2016-08-17 11:12:27.367 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR type=kv
2016-08-17 11:12:27.367 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR flags=0
2016-08-17 11:12:27.368 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR expiretime=0
2016-08-17 11:12:27.369 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR type=kv
2016-08-17 11:12:27.370 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR flags=0
2016-08-17 11:12:27.370 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR expiretime=0
2016-08-17 11:12:27.371 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR type=kv
2016-08-17 11:12:27.372 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR flags=0
2016-08-17 11:12:27.372 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR expiretime=0
2016-08-17 11:12:27.374 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR type=kv
2016-08-17 11:12:27.375 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR flags=0
2016-08-17 11:12:27.376 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR expiretime=0
2016-08-17 11:12:27.377 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR type=kv
2016-08-17 11:12:27.377 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR flags=0
2016-08-17 11:12:27.378 ERROR net.spy.memcached.protocol.ascii.GetAttrOperationImpl:  Unexpected operation status : ATTR expiretime=0
...

net.spy.memcached.internal.CheckedOperationTimeoutException: Timed out waiting for operation. >3 - failing node: /10.144.146.17:11211 [READING] [#
Tops=406766 #iq=1 #Wops=0 #Rops=1 #CT=1 #TR=-1]

        for (MemcachedNode node : locator.getAll()) {
            if (addrs.contains((InetSocketAddress) node.getSocketAddress())) {
                addrs.remove((InetSocketAddress) node.getSocketAddress());
            } else {
                removeNodes.add(node);
            }
        }

        // Make connections to the newly added nodes.
        for (SocketAddress sa : addrs) {
            attachNodes.add(attachMemcachedNode(sa));
        }

        // Update the hash.
        locator.update(attachNodes, removeNodes);

        // Remove unavailable nodes in the reconnect queue.
        for (MemcachedNode node : removeNodes) {
            getLogger().info("old memcached node removed %s", node);
            for (Entry<Long, MemcachedNode> each : reconnectQueue.entrySet()) {
                if (node.equals(each.getValue())) {
                    reconnectQueue.remove(each.getKey());
                    break;
                }
            }
            String cause = "node removed.";
            if (failureMode == FailureMode.Cancel) {
                cancelOperations(node.destroyWriteQueue(false), cause);
                cancelOperations(node.destroyInputQueue(), cause);
            } else if (failureMode == FailureMode.Redistribute || failureMode == FailureMode.Retry) {
                redistributeOperations(node.destroyWriteQueue(true), cause);
                redistributeOperations(node.destroyInputQueue(), cause);
            }
        }

    public final void setupResend(boolean cancelWrite, String cause) {
        // First, reset the current write op, or cancel it if we should
        // be authenticating
        Operation op=getCurrentWriteOp();
        if((cancelWrite || shouldAuth) && op != null) {
            op.cancel(cause);
        } else if(op != null) {
            ByteBuffer buf=op.getBuffer();
            if(buf != null) {
                buf.reset();
            } else {
                getLogger().info("No buffer for current write op, removing");
                removeCurrentWriteOp();
            }
        }
        // Now cancel all the pending read operations.  Might be better to
        // to requeue them.
        while(hasReadOp()) {
            op=removeCurrentReadOp();
            if (op != getCurrentWriteOp()) {
                getLogger().warn("Discarding partially completed op: %s", op);
                op.cancel(cause);
            }
        }

        while((cancelWrite || shouldAuth) && hasWriteOp()) {
            op=removeCurrentWriteOp();
            getLogger().warn("Discarding partially completed op: %s", op);
            op.cancel(cause);
        }


        getWbuf().clear();
        getRbuf().clear();
        toWrite=0;
    }