Java NetResponseSchema类代码示例

import com.ociweb.pronghorn.network.schema.NetResponseSchema; //导入依赖的package包/类
public NetResponseJSONStage(GraphManager graphManager, Class<T> keys,  MapJSONToPipeBuilder<M,T> mapper, Pipe<NetResponseSchema> input, int bottom, Pipe<M> output, Pipe ... otherOutputs) {
	super(graphManager, input, join(otherOutputs, output));
	this.input = input;
	this.output = output;
	this.bottomOfJSON = bottom;
	
	boolean debug = false;
	
	this.keys = debug ? null : keys;	
	this.mapper = debug ? null : mapper;
	
	if (debug) {
		this.visitor = new JSONStreamVisitorCapture(System.out);
	}
	
}
 

import com.ociweb.pronghorn.network.schema.NetResponseSchema; //导入依赖的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.NetResponseSchema; //导入依赖的package包/类
private int endOfHeaderProcessing(int i, final int stateIdx, DataOutputBlobWriter<NetResponseSchema> writer) {
	int state;
	//all done with header move on to body
	writer.writeShort((short)-1); //END OF HEADER FIELDS 		
	
	//Now write header message, we know there is room because we checked before starting.
					    
	if (payloadLengthData[i] == -1) {
		positionMemoData[stateIdx]= state= 3;	
		payloadLengthData[i] = 0;//starting chunk size.			

	} else {
		positionMemoData[stateIdx]= state= 2;
	}
	return state;
}
 

import com.ociweb.pronghorn.network.schema.NetResponseSchema; //导入依赖的package包/类
private Pipe<NetResponseSchema> buildNetResponsePipe() {
	Pipe<NetResponseSchema> netResponsePipe = new Pipe<NetResponseSchema>(builder.pcm.getConfig(NetResponseSchema.class)) {
		@SuppressWarnings("unchecked")
		@Override
		protected DataInputBlobReader<NetResponseSchema> createNewBlobReader() {
			return new HTTPResponseReader(this);
		}
	};
	return netResponsePipe;
}
 

import com.ociweb.pronghorn.network.schema.NetResponseSchema; //导入依赖的package包/类
public OAuth1RequestTokenResponseStage(GraphManager graphManager, 
		Pipe<NetResponseSchema> input,
		Pipe<ServerResponseSchema>[] output,
		HTTPSpecification<?, ?, ?, ?> httpSpec) {
	super(graphManager, input, output);
	this.httpSpec = httpSpec;
	this.output = output;
	this.input = input;
}
 

import com.ociweb.pronghorn.network.schema.NetResponseSchema; //导入依赖的package包/类
public NetResponseDumpStage(GraphManager graphManager, 
		                    Pipe<NetResponseSchema> input, 
		                    A target, 
		                    HTTPSpecification<?, ?, ?, ?> httpSpec) {
	super(graphManager, input, NONE);
	this.input = input;
	this.target = target;
	this.httpSpec = httpSpec;
}
 

import com.ociweb.pronghorn.network.schema.NetResponseSchema; //导入依赖的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.NetResponseSchema; //导入依赖的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.NetResponseSchema; //导入依赖的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();
	
}
 

import com.ociweb.pronghorn.network.schema.NetResponseSchema; //导入依赖的package包/类
public TwitterJSONToTwitterEventsStage(GraphManager graphManager,
									   int bottom,
									   boolean sendPostIds,
		                               Pipe<NetResponseSchema> input, 
		                               Pipe<TwitterStreamControlSchema> control,
		                               Pipe<TwitterEventSchema> output) {
			
	super(graphManager, TwitterKey.class, customJSONMapper(), input, bottom, output, control);
	this.control = control;
	this.sendPostIds = sendPostIds;
}
 

import com.ociweb.pronghorn.network.schema.NetResponseSchema; //导入依赖的package包/类
public static Pipe<TwitterEventSchema> buildStage(GraphManager gm, boolean sendPostIds, int bottom, Pipe<NetResponseSchema> clientResponsesPipe ,
		Pipe<TwitterStreamControlSchema> control,
		int tweetsCount) {
	
	Pipe<TwitterEventSchema> hosePipe = TwitterEventSchema.instance.newPipe(tweetsCount, MAX_TWEET_TEXT_SIZE);
	new TwitterJSONToTwitterEventsStage(gm, bottom, sendPostIds, clientResponsesPipe, control, hosePipe);
	return hosePipe;
}
 

import com.ociweb.pronghorn.network.schema.NetResponseSchema; //导入依赖的package包/类
public HTTP1xResponseParserStage(GraphManager graphManager, 
		                       Pipe<NetPayloadSchema>[] input, 
		                       Pipe<NetResponseSchema>[] output, 
		                       Pipe<ReleaseSchema> ackStop,
		                       ClientCoordinator ccm,
		                       HTTPSpecification<?,?,?,?> httpSpec) {
	
	super(graphManager, input, join(output,ackStop));
	this.input = input;
	this.output = output;//must be 1 for each listener
	this.ccm = ccm;
	this.releasePipe = ackStop;
	this.httpSpec = httpSpec;		
	
	int i = input.length;
	while (--i>=0) {
		assert(	input[i].sizeOfBlobRing >=  MAX_VALID_HEADER*2 ); //size of blob ring is the largest a header can ever be.			
	}
	
	assert(this.httpSpec.headerMatches(H_TRANSFER_ENCODING, HTTPHeaderDefaults.TRANSFER_ENCODING.writingRoot()));
	assert(this.httpSpec.headerMatches(H_CONTENT_LENGTH, HTTPHeaderDefaults.CONTENT_LENGTH.writingRoot()));		
	assert(this.httpSpec.headerMatches(H_CONTENT_TYPE, HTTPHeaderDefaults.CONTENT_TYPE.writingRoot()));
	
	this.UNSUPPORTED_HEADER_ID  = httpSpec.headerCount+2;
	this.END_OF_HEADER_ID       = httpSpec.headerCount+3;//for the empty header found at the bottom of the header
	
	GraphManager.addNota(graphManager, GraphManager.DOT_BACKGROUND, "lavenderblush", this);
	
}
 

import com.ociweb.pronghorn.network.schema.NetResponseSchema; //导入依赖的package包/类
private boolean outputsHaveRoom(Pipe<NetResponseSchema>[] output) {
	
	int i = output.length;
	while (--i>=0) {
		if (!Pipe.hasRoomForWrite(output[i])) {
			return false;
		}
	}
	
	return true;
}
 

import com.ociweb.pronghorn.network.schema.NetResponseSchema; //导入依赖的package包/类
public static void buildHTTP1xResponseParser(GraphManager gm, ClientCoordinator ccm, 
		Pipe<NetResponseSchema>[] responses, Pipe<NetPayloadSchema>[] clearResponse,
		Pipe<ReleaseSchema> ackRelease) {
	
	HTTP1xResponseParserStage parser = new HTTP1xResponseParserStage(gm, clearResponse, responses, ackRelease, ccm, HTTPSpecification.defaultSpec());
	GraphManager.addNota(gm, GraphManager.DOT_RANK_NAME, "HTTPParser", parser);
	ccm.processNota(gm, parser);
	
}
 

import com.ociweb.pronghorn.network.schema.NetResponseSchema; //导入依赖的package包/类
private static void buildParser(GraphManager gm, ClientCoordinator ccm, 
		Pipe<NetResponseSchema>[] responses, Pipe<NetPayloadSchema>[] clearResponse, Pipe<ReleaseSchema>[] acks) {
	
	HTTP1xResponseParserStage parser = new HTTP1xResponseParserStage(gm, clearResponse, responses, acks[acks.length-1], ccm, HTTPSpecification.defaultSpec());
	GraphManager.addNota(gm, GraphManager.DOT_RANK_NAME, "HTTPParser", parser);
	ccm.processNota(gm, parser);
}