public <S extends MessageSchema<S>> PipeConfig<S> getConfig(Class<S> clazz) { int idx = findIndex(clazz); if (idx>=0) { return (PipeConfig<S>)configs[idx]; } //when undefined build store and return the default return addConfig(defaultMinimumFragmentsOnPipe, defaultMaximumLengthOfVariableLengthFields, clazz); }
public static Pipe<MessageSubscription> buildMessageSubscriptionPipe(BuilderImpl b) { Pipe<MessageSubscription> subscriptionPipe = new Pipe<MessageSubscription>(b.pcm.getConfig(MessageSubscription.class)) { @SuppressWarnings("unchecked") @Override protected DataInputBlobReader<MessageSubscription> createNewBlobReader() { return new MessageReader(this); } }; return subscriptionPipe; }
protected PipeConfigManager buildPipeManager() { PipeConfigManager pcm = new PipeConfigManager(4,2,128); pcm.addConfig(defaultCommandChannelLength,0,TrafficOrderSchema.class ); return pcm; }
public <S extends MessageSchema<S>> PipeConfig<S> getConfig(Class<S> clazz) { S instance = MessageSchema.findInstance(clazz); final int idx = findIndex(instance); if (idx>=0) { return (PipeConfig<S>)configs[idx]; } return buildNewConfig(instance); }
new SocketValidator(), false/*Do not grow*/); serverPipesConfig.pcmIn.ensureSize(HTTPRequestSchema.class, serverPipesConfig.fromRouterToModuleCount, this.connectionStruct().inFlightPayloadSize()); serverPipesConfig.pcmOut.addConfig(serverPipesConfig.pcmOut.getConfig(NetPayloadSchema.class));
public static void growCommandCountRoom(MsgCommandChannel<?> cmd, int count) { if (cmd.isInit) { throw new UnsupportedOperationException("Too late, growCommandCountRoom method must be called in define behavior."); } PipeConfig<TrafficOrderSchema> goConfig = cmd.pcm.getConfig(TrafficOrderSchema.class); cmd.pcm.addConfig(count + goConfig.minimumFragmentsOnPipe(), 0, TrafficOrderSchema.class); }
@Override public HTTPClientConfig setResponseQueueLength(int value) { this.pcm.ensureSize(NetResponseSchema.class, value, 32); return this; }
pcm.ensureSize(NetPayloadSchema.class, 8, SSLUtil.MinTLSBlock); ///must be large enough for encrypt/decrypt PipeConfig<NetPayloadSchema> clientNetRequestConfig = pcm.getConfig(NetPayloadSchema.class);
public <S extends MessageSchema<S>> PipeConfig<S> addConfig(int minimumFragmentsOnPipe,final int maximumLengthOfVariableLengthFields, Class<S> clazz) { PipeConfig<S> newConfig = MessageSchema .findInstance(clazz) .newPipeConfig(minimumFragmentsOnPipe, maximumLengthOfVariableLengthFields); return addConfig(newConfig); }
public <S extends MessageSchema<S>> PipeConfig<S> addConfig(PipeConfig<S> newConfig) { int idx = findIndex(newConfig.schema); if (idx<0) { if (configCount >= configs.length) { //grow, we are out of room PipeConfig[] newConfigs = new PipeConfig[configs.length*2]; System.arraycopy(configs, 0, newConfigs, 0, configs.length); configs = newConfigs; } configs[configCount++] = newConfig; } else { configs[idx] = newConfig; } return newConfig; }
public static HTTPServerConfig serverConfig(int port, GraphManager gm) { return new HTTPServerConfigImpl(port, new PipeConfigManager(), new PipeConfigManager(), gm.recordTypeData); }
@Override public HTTPClientConfig setMaxRequestSize(int value) { this.pcm.ensureSize(NetPayloadSchema.class, 4, value); //System.out.println("set max size: "+value+" maxVar:"+pcm.getConfig(NetPayloadSchema.class).maxVarLenSize()+" "+pcm.getConfig(NetPayloadSchema.class)); return this; }
HTTPServerConfigImpl r = ((HTTPServerConfigImpl) config); r.pcmOut.ensureSize(ServerResponseSchema.class, 4, r.getMaxResponseSize()); r.pcmIn.ensureSize(ReleaseSchema.class, 1<<16, 0);//for high volume r.pcmOut.ensureSize(ReleaseSchema.class, 1<<16, 0);//for high volume serverConfig.pcmIn.getConfig(NetPayloadSchema.class)); serverConfig.pcmIn.getConfig(NetPayloadSchema.class)); handshakeIncomingGroup = NetGraphBuilder.populateGraphWithUnWrapStages(gm, serverCoord, serverConfig.serverRequestUnwrapUnits, serverConfig.pcmIn.getConfig(NetPayloadSchema.class), encryptedIncomingGroup, planIncomingGroup, acks); } else {
public <S extends MessageSchema<S>> PipeConfig<S> addConfig(int minimumFragmentsOnPipe, int maximumLengthOfVariableLengthFields, Class<S> clazz) { PipeConfig<S> newConfig = MessageSchema .findInstance(clazz) .newPipeConfig(minimumFragmentsOnPipe, maximumLengthOfVariableLengthFields); return addConfig(newConfig); }
public <S extends MessageSchema<S>> PipeConfig<S> addConfig(PipeConfig<S> newConfig) { int idx = findIndex(newConfig.schema); if (idx<0) { if (configCount >= configs.length) { //grow, we are out of room PipeConfig[] newConfigs = new PipeConfig[configs.length*2]; System.arraycopy(configs, 0, newConfigs, 0, configs.length); configs = newConfigs; } configs[configCount++] = newConfig; } else { //if (configs[idx].minimumFragmentsOnPipe()>newConfig.minimumFragmentsOnPipe()) { // throw new UnsupportedOperationException("Already ensured size larger than new assignment, use ensure not add."); //} configs[idx] = newConfig; } return newConfig; }
@Override public HTTPServerConfig useHTTP1xServer(int bindPort) { if (server != null) { throw new RuntimeException("Server already enabled"); } if (this.behaviorTracksDefinition == null) { this.behaviorTracksDefinition = new DeclareBehavior<R>() { @Override public void declareBehavior(R runtime) { } }; } return server = new HTTPServerConfigImpl(bindPort, pcm, new PipeConfigManager(), gm.recordTypeData); }
public <S extends MessageSchema<S>> PipeConfig<S> getConfig(Class<S> clazz) { S instance = MessageSchema.findInstance(clazz); final int idx = findIndex(instance); if (idx>=0) { return (PipeConfig<S>)configs[idx]; } return buildNewConfig(instance); }
public Pipe<NetResponseSchema> buildNetResponsePipe() { Pipe<NetResponseSchema> netResponsePipe = new Pipe<NetResponseSchema>(pcm.getConfig(NetResponseSchema.class)) { @SuppressWarnings("unchecked") @Override protected DataInputBlobReader<NetResponseSchema> createNewBlobReader() { return new HTTPResponseReader(this, httpSpec); } }; return netResponsePipe; }
public <S extends MessageSchema<S>> void ensureSize(Class<S> clazz, int queueLength, int maxMessageSize) { int idx = findIndex(clazz); if (idx>=0) { //we found it PipeConfig<S> oldConfig = (PipeConfig<S>)configs[idx]; int oldQueueLen = oldConfig.minimumFragmentsOnPipe(); int oldMaxVarLenSize = oldConfig.maxVarLenSize(); if (queueLength>oldQueueLen || maxMessageSize>oldMaxVarLenSize) { addConfig(Math.max(oldQueueLen,queueLength), Math.max(oldMaxVarLenSize, maxMessageSize), clazz); } } else { //add it was not found addConfig(Math.max(queueLength,defaultMinimumFragmentsOnPipe),Math.max(maxMessageSize, defaultMaximumLengthOfVariableLengthFields),clazz); } }
@Override public HTTPClientConfig setMaxResponseSize(int value) { //System.out.println("response size: "+value); this.pcm.ensureSize(NetResponseSchema.class, 4, value); return this; }