Java ClientHTTPRequestSchema类代码示例

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
/**
 * Parse HTTP data on feed and sends back an ack to the  SSLEngine as each message is decrypted.
 * 
 * @param graphManager
 * @param hardware
 * @param input
 * @param goPipe
 * @param ackPipe
 * @param output
 */

public HTTPClientRequestTrafficStage(
		GraphManager graphManager, 
		MsgRuntime<?,?> runtime,
		BuilderImpl hardware,
		ClientCoordinator ccm,
		
           Pipe<ClientHTTPRequestSchema>[] input,
           Pipe<TrafficReleaseSchema>[] goPipe,
           Pipe<TrafficAckSchema>[] ackPipe,
           
           Pipe<NetPayloadSchema>[] output
           ) {
	
	super(graphManager, runtime, hardware, input, goPipe, ackPipe, output);
	this.input = input;
	this.output = output;
	this.ccm = ccm;
	
	assert(ccm.isTLS == hardware.getHTTPClientConfig().isTLS());
	
	GraphManager.addNota(graphManager, GraphManager.DOT_BACKGROUND, "lavenderblush", this);
	GraphManager.addNota(graphManager, GraphManager.LOAD_MERGE, GraphManager.LOAD_MERGE, this);
	
}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
public static RequestTwitterQueryStreamStage newInstance(GraphManager gm,
									String consumerKey, String consumerSecret,
									int maxCount,
									int[] queryResponseIds, 
									String[] queryStrings,
									int bearerRequestResponseId, 			
									Pipe<TwitterStreamControlSchema>[] streamControlPipe, //Bad bearer detected or bad data
									Pipe<NetResponseSchema> newBearerPipe, //new Bearer arrives here
									Pipe<ClientHTTPRequestSchema> httpRequest //send out request for Bearer or Query request
		) {
	
	return new RequestTwitterQueryStreamStage(gm, consumerKey, consumerSecret,
											  maxCount, queryResponseIds, queryStrings,
			                                  bearerRequestResponseId,
											  streamControlPipe, newBearerPipe, httpRequest);
}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
public RequestTwitterUserStreamStage(GraphManager graphManager, 
										String ck, String cs, 
										String token, String secret, 
										int httpRequestResponseId,
										Pipe<TwitterStreamControlSchema> control,
		                                Pipe<ClientHTTPRequestSchema> output) {
	
	super(graphManager, control, output);
	this.control = control;
	this.output = output;
	
	this.ck = ck;
	this.cs = cs;
	this.token = token;
	this.secret = secret;
	this.httpRequestResponseId = httpRequestResponseId;		
}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
private void streamingRequest(Pipe<ClientHTTPRequestSchema> pipe, int httpRequestResponseId) {
		
	PipeWriter.presumeWriteFragment(pipe, ClientHTTPRequestSchema.MSG_HTTPGET_100);
	assert(httpRequestResponseId>=0);
	PipeWriter.writeInt(pipe, ClientHTTPRequestSchema.MSG_HTTPGET_100_FIELD_DESTINATION_11, httpRequestResponseId);
	PipeWriter.writeInt(pipe, ClientHTTPRequestSchema.MSG_HTTPGET_100_FIELD_SESSION_10, httpRequestResponseId);
	PipeWriter.writeInt(pipe, ClientHTTPRequestSchema.MSG_HTTPGET_100_FIELD_PORT_1, port);
	PipeWriter.writeUTF8(pipe, ClientHTTPRequestSchema.MSG_HTTPGET_100_FIELD_HOST_2, host);
	PipeWriter.writeUTF8(pipe, ClientHTTPRequestSchema.MSG_HTTPGET_100_FIELD_PATH_3, path);
			
	DataOutputBlobWriter<ClientHTTPRequestSchema> stream = PipeWriter.outputStream(pipe);
	DataOutputBlobWriter.openField(stream);
	myAuth.addHeaders(stream, "GET").append("\r\n");
	
	//myAuth.addHeaders(System.out, "GET");
	
	DataOutputBlobWriter.closeHighLevelField(stream, ClientHTTPRequestSchema.MSG_HTTPGET_100_FIELD_HEADERS_7);

	PipeWriter.publishWrites(pipe);
}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
private void processShutdownLogic(Pipe<ClientHTTPRequestSchema> requestPipe) {
	ClientConnection connectionToKill = ccm.nextValidConnection();
	final ClientConnection firstToKill = connectionToKill;					
	while (null!=connectionToKill) {								
		connectionToKill = ccm.nextValidConnection();
		
		//must send handshake request down this pipe
		int pipeId = connectionToKill.requestPipeLineIdx();
		
		HTTPClientUtil.cleanCloseConnection(connectionToKill, output[pipeId]);
											
		if (firstToKill == connectionToKill) {
			break;//done
		}
	}
	
	shutdownInProgress = true;
	Pipe.confirmLowLevelRead(requestPipe, Pipe.EOF_SIZE);
	Pipe.releaseReadLock(requestPipe);
}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
@Test
public void testStageGen() {
	
	int testDuration = 100;
	int generatorSeed = 51;
	assertTrue(StageTester.runFuzzTest(FuzzGeneratorStage.class, testDuration, generatorSeed, 
			                new MessageSchema[]{RawDataSchema.instance},
			                new Object[]{new Random(42),10L}));
	
	assertTrue(StageTester.runFuzzTest(FuzzGeneratorStage.class, testDuration, generatorSeed, 
							new MessageSchema[]{ClientHTTPRequestSchema.instance},
							new Object[]{new Random(42),10L}));
	
	assertTrue(StageTester.runFuzzTest(FuzzGeneratorStage.class, testDuration, generatorSeed, 
							new MessageSchema[]{PipeMonitorSchema.instance},
							new Object[]{new Random(42),10L}));
		
}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
@Test
	public void testStageJSONDump() {
		
		int testDuration = 100;
		int generatorSeed = 13;
		
		assertTrue(StageTester.runFuzzTest(ConsoleJSONDumpStage.class, testDuration, generatorSeed++, 
							RawDataSchema.instance, false));
					       //never true above since RawDataSchema is NOT defined as UTF8
					
		assertTrue(StageTester.runFuzzTest(ConsoleJSONDumpStage.class, testDuration, generatorSeed++, 
							ClientHTTPRequestSchema.instance, false));
							//never true above since payload is NOT defined as UTF8
					
		assertTrue(StageTester.runFuzzTest(ConsoleJSONDumpStage.class, testDuration, generatorSeed++, 
							PipeMonitorSchema.instance, false));

		assertTrue(StageTester.runFuzzTest(ConsoleJSONDumpStage.class, testDuration, generatorSeed++, 
							PipeMonitorSchema.instance, true));

;
			
	}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
public void ensureHTTPClientRequesting(int queueLength, int maxMessageSize) {
	if (isInit) {
		throw new UnsupportedOperationException("Too late, ensureHTTPClientRequesting method must be called in define behavior.");
	}
	growCommandCountRoom(queueLength);
	this.initFeatures |= NET_REQUESTER;
	
	pcm.ensureSize(ClientHTTPRequestSchema.class, queueLength, maxMessageSize);

}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
private static <B extends BuilderImpl> Pipe<ClientHTTPRequestSchema> newNetRequestPipe(PipeConfig<ClientHTTPRequestSchema> config, B builder) {

    	return new Pipe<ClientHTTPRequestSchema>(config) {
			@Override
			protected DataOutputBlobWriter<ClientHTTPRequestSchema> createNewBlobWriter() {
				return new PayloadWriter<ClientHTTPRequestSchema>(this);
			}    		
    	};
    }
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
public GreenCommandChannel newCommandChannel(int features) { 
    
	PipeConfigManager pcm = new PipeConfigManager(4, defaultCommandChannelLength, 
			                                         defaultCommandChannelMaxPayload);

	pcm.addConfig(defaultCommandChannelLength, defaultCommandChannelHTTPMaxPayload, ClientHTTPRequestSchema.class);
	pcm.addConfig(defaultCommandChannelLength,0,TrafficOrderSchema.class);
	
	return this.builder.newCommandChannel(
features,
parallelInstanceUnderActiveConstruction,
pcm
);    	
}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
public OAuth1RequestTokenStage(GraphManager graphManager, 
		                       Pipe<HTTPRequestSchema>[] inputs, 
		                       Pipe<ClientHTTPRequestSchema> clientRequestsPipe,
		                       int responseId,
		                       HTTPSpecification<?, ?, ?, ?> httpSpec) {
	
	super(graphManager, inputs, clientRequestsPipe);
	this.inputs = inputs;
	this.clientRequestsPipe = clientRequestsPipe;
	this.httpSpec = httpSpec;
	this.responseId = responseId;
}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
private static void writeHeaders(String ck, String cs, DataOutputBlobWriter<ClientHTTPRequestSchema> stream) {
//	byte[] btc = encodeKeys(ck,cs).getBytes();//
	byte[] btc = (ck+':'+cs).getBytes();  //TODO: not GC free...
	//Authorization: Basic UW5KTlFsWnlkemRXVDNSV2RrWTVaSFo2TWs1Tk5EbEZZanBvTW5VNU5UQlpOVUZFZVdOa1JqSlNXV1p1V0daNE5sUkJaRVpaTlZZeE4xZDVSazFsTVVSS2JrSlBSMVZqZVVNM1lRPT0=

	stream.append("Authorization: Basic ");
	Appendables.appendBase64Encoded(stream, btc, 0, btc.length, Integer.MAX_VALUE);
	stream.append("\r\nContent-Type: application/x-www-form-urlencoded;charset=UTF-8\r\n");
}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
public static RequestTwitterFriendshipStage newFollowInstance(GraphManager graphManager,
		String ck, String cs, 
		String token, String secret, 
		Pipe<HTTPRequestSchema> inputs, Pipe<ServerResponseSchema> outputs,
		int httpRequestResponseId,
		Pipe<ClientHTTPRequestSchema> toTwitter, Pipe<NetResponseSchema> fromTwitter) {
	return new RequestTwitterFriendshipStage(graphManager, ck, cs, token, secret, 
			inputs, outputs, httpRequestResponseId, toTwitter, fromTwitter, followPath, "follow=true".getBytes());			 
}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
public static RequestTwitterFriendshipStage newUnFollowInstance(GraphManager graphManager,
		String ck, String cs, 
		String token, String secret, 
		Pipe<HTTPRequestSchema> inputs, Pipe<ServerResponseSchema> outputs,
		int httpRequestResponseId,
		Pipe<ClientHTTPRequestSchema> toTwitter, Pipe<NetResponseSchema> fromTwitter) {
	return new RequestTwitterFriendshipStage(graphManager, ck, cs, token, secret, 
			inputs, outputs, httpRequestResponseId, toTwitter, fromTwitter, unfollowPath);			 
}
 

import com.ociweb.pronghorn.network.schema.ClientHTTPRequestSchema; //导入依赖的package包/类
private RequestTwitterFriendshipStage(
		GraphManager graphManager,
		String ck, String cs, 
		String token, String secret, 
		Pipe<HTTPRequestSchema> inputs, 
		Pipe<ServerResponseSchema> outputs,
		int httpRequestResponseId,
		Pipe<ClientHTTPRequestSchema> toTwitter, 
		Pipe<NetResponseSchema> fromTwitter,
		String path,
		byte[] ... postItems
		) {
	
	super(graphManager, join(inputs, fromTwitter), join(outputs, toTwitter));
	
	this.inputs = inputs;
	this.outputs = outputs;
	this.toTwitter = toTwitter;
	this.fromTwitter = fromTwitter;
	
	this.ck = ck;
    this.cs = cs;
	this.token = token;
	this.secret = secret;
		
	this.path = path;
	this.pathBytes = path.getBytes();
	this.postItems = postItems;	
	this.httpRequestResponseId = httpRequestResponseId;
	
	this.msBetweenCalls = (24*60*60*1000)/1000;  //(15*60*1000)/15; 15 min limit
	assert(86_400 == msBetweenCalls);  //24 hour limit of 1000
	this.dynamicLength = new StringBuilder();
	
}