Java IApimanBuffer类代码示例

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
@Test
public void changeResponseWhenCallbackParamNameIsSavedInContext() throws Exception {
    JsonpConfigBean config = new JsonpConfigBean();

    // given
    String functionName = "testFunction";
    sContext.setAttribute(JsonpPolicy.CALLBACK_FUNCTION_NAME, functionName);
    ApiResponse response = new ApiResponse();
    String json = "{\"name\": \"test\"}";
    IApimanBuffer chunk = new ByteBuffer(json.getBytes().length);
    chunk.append(json);
    IAsyncHandler<IApimanBuffer> bodyHandler = mock(IAsyncHandler.class);
    // when
    IReadWriteStream<ApiResponse> responseDataHandler = jsonpPolicy.getResponseDataHandler(response, sContext, config);
    ApiResponse head = responseDataHandler.getHead();
    responseDataHandler.bodyHandler(bodyHandler);
    responseDataHandler.write(chunk);
    responseDataHandler.end();
    // then
    assertSame(response, head);

    verify(bodyHandler).handle(refEq(new ByteBuffer("testFunction(")));
    verify(bodyHandler).handle(refEq(new ByteBuffer(json)));
    verify(bodyHandler).handle(refEq(new ByteBuffer(")")));
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
/**
 * @see io.apiman.gateway.engine.io.IWriteStream#write(io.apiman.gateway.engine.io.IApimanBuffer)
 */
@Override
public void write(IApimanBuffer chunk) {
    try {
        if (!connected) {
            throw new IOException("Not connected."); //$NON-NLS-1$
        }
        if (outputStream == null) {
            outputStream = connection.getOutputStream();
        }
        if (chunk instanceof ByteBuffer) {
            byte[] buffer = (byte[]) chunk.getNativeBuffer();
            outputStream.write(buffer, 0, chunk.length());
        } else {
            outputStream.write(chunk.getBytes());
        }
    } catch (IOException e) {
        handleConnectionError(e);
    }
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
@Override
public void write(IApimanBuffer chunk) {
    if (inboundFinished) {
        throw new IllegalStateException(Messages.getString("HttpConnector.0"));
    }

    if (chunk.getNativeBuffer() instanceof Buffer) {
        clientRequest.write((Buffer) chunk.getNativeBuffer());
        // When write queue has diminished sufficiently, drain handler will be invoked.
        if (clientRequest.writeQueueFull() && drainHandler != null) {
            clientRequest.drainHandler(drainHandler::handle);
        }
    } else {
        throw new IllegalArgumentException(Messages.getString("HttpConnector.1"));
    }
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
@Before
public void setup() {
    Policy policyBean = mock(Policy.class);
    given(policyBean.getPolicyImpl()).willReturn(PassthroughPolicy.QUALIFIED_NAME);
    given(policyBean.getPolicyJsonConfig()).willReturn("{}");

    mockBufferInbound = mock(IApimanBuffer.class);
    given(mockBufferInbound.toString()).willReturn("stottie");

    mockBufferOutbound = mock(IApimanBuffer.class);
    given(mockBufferOutbound.toString()).willReturn("bacon");

    policyList = new ArrayList<>();
    policyList.add(policyBean);

    mockBodyHandler = mock(IAsyncHandler.class);
    mockEndHandler = mock(IAsyncHandler.class);
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
@Test
public void shouldPreserveBufferOrder() {
    policies.add(pwcOne);
    requestChain = new RequestChain(policies, mockContext);
    requestChain.bodyHandler(mockBodyHandler);
    requestChain.endHandler(mockEndHandler);

    requestChain.doApply(mockRequest);

    IApimanBuffer buffer1 = mock(IApimanBuffer.class);
    IApimanBuffer buffer2 = mock(IApimanBuffer.class);
    IApimanBuffer buffer3 = mock(IApimanBuffer.class);

    requestChain.write(buffer1);
    requestChain.write(buffer2);
    requestChain.write(buffer3);

    requestChain.end();

    InOrder order = inOrder(mockBodyHandler, mockEndHandler);
    order.verify(mockBodyHandler).handle(buffer1);
    order.verify(mockBodyHandler).handle(buffer2);
    order.verify(mockBodyHandler).handle(buffer3);
    order.verify(mockEndHandler).handle((Void) null);
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
/**
 * See {@link AbstractMappedDataPolicy#responseDataHandler(ApiResponse, IPolicyContext, Object)}
 */
@Override
protected IReadWriteStream<ApiResponse> responseDataHandler(final ApiResponse response,
                                                            final IPolicyContext context,
                                                            final CookieRemoveConfigBean config) {
    // short-circuit
    if (context.getAttribute(ATTRIBUTE_SKIP, false)) {
        return null;
    }

    if (ResponseBehaviour.PassThrough.equals(config.getResponseBehaviour())) {
        // default response behaviour
        return null;

    } else {
        // discard response body from back-end service
        return new AbstractStream<ApiResponse>() {
            @Override
            protected void handleHead(ApiResponse head) {
            }

            @Override
            public ApiResponse getHead() {
                return response;
            }

            @Override
            public void write(IApimanBuffer chunk) {
                // discard chunk
            }
        };
    }
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
private Buffer getNativeBuffer(IApimanBuffer buffer) {
	if (buffer.getNativeBuffer() instanceof Buffer) {
		return (Buffer) buffer.getNativeBuffer();
	} else {
		logger.debug("Received an IApimanBuffer with a non-Vert.x implementation. " //$NON-NLS-1$
				+ "This will function but may require copying and be less efficient."); //$NON-NLS-1$
		return Buffer.buffer(buffer.getBytes());
	}
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
/**
 * @see io.apiman.gateway.engine.components.ICacheStoreComponent#putBinary(java.lang.String, java.lang.Object, long)
 */
@Override
public <T> ISignalWriteStream putBinary(final String cacheKey, final T jsonObject, final long timeToLive)
        throws IOException {
    final IApimanBuffer dataBuffer = bufferFactory.createBuffer(0);
    return new ISignalWriteStream() {
        private boolean finished = false;
        private boolean aborted = false;
        @Override
        public void abort(Throwable t) {
            aborted = true;
            finished = false;
        }
        @Override
        public boolean isFinished() {
            return finished;
        }
        @Override
        public void write(IApimanBuffer chunk) {
            dataBuffer.append(chunk);
        }
        @Override
        public void end() {
            if (!aborted) {
                synchronized (mutex) {
                    InfinispanCacheEntry entry = (InfinispanCacheEntry) getCache().get(cacheKey);
                    if (entry == null) {
                        entry = new InfinispanCacheEntry();
                    }
                    entry.setHead(jsonObject);
                    entry.setExpiresOn(System.currentTimeMillis() + (timeToLive * 1000));
                    entry.setData(dataBuffer.getBytes());
                    getCache().put(cacheKey, entry);
                }
            }
        }
    };
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
/**
 * @see io.apiman.gateway.engine.io.AbstractStream#write(io.apiman.gateway.engine.io.IApimanBuffer)
 */
@Override
public void write(IApimanBuffer chunk) {
    if (buffer == null) {
        buffer = bufferFactory.cloneBuffer(chunk);
    } else {
        buffer.append(chunk);
    }
    atEnd = false;
    processBuffer();
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
/**
 * @see io.apiman.gateway.engine.policies.AbstractMappedDataPolicy#requestDataHandler(io.apiman.gateway.engine.beans.ApiRequest, io.apiman.gateway.engine.policy.IPolicyContext, java.lang.Object)
 */
@Override
protected IReadWriteStream<ApiRequest> requestDataHandler(final ApiRequest request,
        final IPolicyContext context, final TransferQuotaConfig config) {
    // *************************************************************
    // Step 2:  if upload quotas are enabled, then count all bytes
    //          uploaded to the back-end API
    // *************************************************************
    if (config.getDirection() == TransferDirectionType.upload || config.getDirection() == TransferDirectionType.both) {
        return new AbstractStream<ApiRequest>() {
            private long total = 0;
            @Override
            public ApiRequest getHead() {
                return request;
            }
            @Override
            protected void handleHead(ApiRequest head) {
            }
            @Override
            public void write(IApimanBuffer chunk) {
                total += chunk.length();
                super.write(chunk);
            }
            @Override
            public void end() {
                context.setAttribute(BYTES_UPLOADED_ATTR, total);
                super.end();
            }
        };
    } else {
        return null;
    }
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
/**
 * @see io.apiman.gateway.engine.policies.AbstractMappedDataPolicy#responseDataHandler(io.apiman.gateway.engine.beans.ApiResponse, io.apiman.gateway.engine.policy.IPolicyContext, java.lang.Object)
 */
@Override
protected IReadWriteStream<ApiResponse> responseDataHandler(final ApiResponse response,
        final IPolicyContext context, final TransferQuotaConfig config) {
    // *************************************************************
    // Step 4:  if download quotas are enabled, then count all bytes
    //          downloaded from the back-end API and store the count
    // ---
    // Note: we have no easy way to fail the request if the download
    //       quota is exceeded - so we'll pass and then fail on the
    //       next request (see Step 1)
    // *************************************************************
    if (config.getDirection() == TransferDirectionType.download || config.getDirection() == TransferDirectionType.both) {
        return new AbstractStream<ApiResponse>() {
            private long total = 0;
            @Override
            public ApiResponse getHead() {
                return response;
            }
            @Override
            protected void handleHead(ApiResponse head) {
            }
            @Override
            public void write(IApimanBuffer chunk) {
                total += chunk.length();
                super.write(chunk);
            }
            @Override
            public void end() {
                doFinalApply(context, config, total);
                super.end();
            }
        };
    } else {
        return null;
    }
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
/**
 * @see io.apiman.gateway.engine.components.ICacheStoreComponent#putBinary(java.lang.String, java.lang.Object, long)
 */
@Override
public <T> ISignalWriteStream putBinary(final String cacheKey, final T jsonObject, final long timeToLive)
        throws IOException {
    final ESCacheEntry entry = new ESCacheEntry();
    entry.setExpiresOn(System.currentTimeMillis() + (timeToLive * 1000));
    entry.setHead(mapper.writeValueAsString(jsonObject));
    final IApimanBuffer data = bufferFactory.createBuffer();
    return new ISignalWriteStream() {
        boolean finished = false;
        boolean aborted = false;
        @Override
        public void abort(Throwable t) {
            finished = true;
            aborted = false;
        }
        @Override
        public boolean isFinished() {
            return finished;
        }
        @Override
        public void write(IApimanBuffer chunk) {
            data.append(chunk);
        }
        @Override
        public void end() {
            if (!aborted) {
                entry.setData(Base64.encodeBase64String(data.getBytes()));
                Index index = new Index.Builder(entry).refresh(false).index(getIndexName())
                        .type("cacheEntry").id(cacheKey).build(); //$NON-NLS-1$
                try {
                    getClient().execute(index);
                } catch (Throwable e) {
                }
            }
            finished = true;
        }
    };
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
/**
 * @see io.apiman.gateway.engine.io.AbstractStream#write(io.apiman.gateway.engine.io.IApimanBuffer)
 */
@Override
public void write(IApimanBuffer chunk) {
    if (finished) {
        throw new IllegalStateException("Attempted write after #end() was called."); //$NON-NLS-1$
    }

    if (headPolicyHandler != null) {
        headPolicyHandler.write(chunk);
    } else {
        handleBody(chunk);
    }
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
/**
 * Append the given data to any existing buffer, then scan the buffer
 * looking for the soap headers.  If scanning is complete, this method
 * will return true.  If more data is required, then the method will return
 * false.  If an error condition is detected, then an exception will be
 * thrown.
 * @param buffer
 */
public boolean scan(IApimanBuffer buffer) throws SoapEnvelopeNotFoundException {
    if (this.buffer == null) {
        this.buffer = buffer;
    } else {
        this.buffer.append(buffer);
    }
    boolean scanComplete = doScan();
    // If our buffer is already "max size" but we haven't found the start of the
    // soap envelope yet, then we're likely not going to find it.
    if (!scanComplete && this.buffer.length() >= getMaxBufferLength()) {
        throw new SoapEnvelopeNotFoundException();
    }
    return scanComplete;
}
 

import io.apiman.gateway.engine.io.IApimanBuffer; //导入依赖的package包/类
public void write(IApimanBuffer chunk) {
    if (fileOS == null) {
        try {
            fileOS = new FileOutputStream(tmpFile);
            fileOS.write(chunk.getBytes());
        } catch (IOException e) {
            // TODO: Log the error.
            // The response will not be cached as it might not contain a valid body
            writeFailed = true;
        }
    }
}