Java BlockingClient类代码示例

import org.quickserver.net.client.BlockingClient; //导入依赖的package包/类
private void sendCmdOutToAll(String data) throws TimeoutException {
	PooledBlockingClient pbc[] = blockingClientPool.getOneBlockingClientForAllActiveHosts();
	if (pbc == null) {
		throw new TimeoutException("we do not have any client array [pbc] to connect to server!");
	}

	for (int i = 0; i < pbc.length; i++) {
		try {
			BlockingClient bc = pbc[i].getBlockingClient();
			if (bc == null) {
				throw new TimeoutException("we do not have any client[bc] to connect to server!");
			}

			bc.sendBytes(data, charset);
		} catch (IOException e) {
			if (pbc != null) {
				logger.log(Level.WARNING, "We had an ioerror will close client! " + e, e);
				pbc[i].close();
			}
		} finally {
			blockingClientPool.returnBlockingClient(pbc[i]);
			pbc[i] = null;
		}
	}

}
 

import org.quickserver.net.client.BlockingClient; //导入依赖的package包/类
private String sendDataOut(String key, String data) throws TimeoutException {
	ClientInfo ci = new ClientInfo();
	ci.setClientKey(key);

	PooledBlockingClient pbc = null;

	try {
		pbc = blockingClientPool.getBlockingClient(ci);
		if (pbc == null) {
			throw new TimeoutException("sdo: we do not have any client[pbc] to connect to server!");
		}

		BlockingClient bc = pbc.getBlockingClient();
		if (bc == null) {
			throw new TimeoutException("we do not have any client[bc] to connect to server!");
		}

		bc.sendBytes(data, charset);

		return bc.readCRLFLine();
	} catch (IOException e) {            
           if (pbc != null) {
			logger.log(Level.WARNING, "We had an ioerror will close client! " + e, e);
			pbc.close();
		}
           if(e instanceof TimeoutException) {
               throw (TimeoutException) e;
           } else {
               throw new TimeoutException("We had ioerror " + e);
           }	
	} finally {
		if (pbc != null) {
			blockingClientPool.returnBlockingClient(pbc);
		}
	}
}
 

import org.quickserver.net.client.BlockingClient; //导入依赖的package包/类
public Map getStats() throws Exception {
	Map<InetSocketAddress, Map<String, String>> map = new HashMap<InetSocketAddress, Map<String, String>>();

	PooledBlockingClient pbc[] = blockingClientPool.getOneBlockingClientForAllActiveHosts();
	if (pbc == null) {
		throw new TimeoutException("we do not have any client array [pbc] to connect to server!");
	}

	Map<String, String> inmap = null;
	for (int i = 0; i < pbc.length; i++) {
		try {
			BlockingClient bc = pbc[i].getBlockingClient();
			if (bc == null) {
				throw new TimeoutException("we do not have any client[bc] to connect to server!");
			}

			inmap = getStats(bc);

			map.put(pbc[i].getSocketBasedHost().getInetSocketAddress(), inmap);
		} catch (IOException e) {
			if (pbc != null) {
				logger.log(Level.WARNING, "We had an ioerror will close client! " + e, e);
				pbc[i].close();
			}
		} finally {
			blockingClientPool.returnBlockingClient(pbc[i]);
			pbc[i] = null;
		}
	}

	return map;
}
 

import org.quickserver.net.client.BlockingClient; //导入依赖的package包/类
public Map getVersions() throws TimeoutException {
	Map<InetSocketAddress, String> map = new HashMap<InetSocketAddress, String>();

	PooledBlockingClient pbc[] = blockingClientPool.getOneBlockingClientForAllActiveHosts();
	if (pbc == null) {
		throw new TimeoutException("we do not have any client array [pbc] to connect to server!");
	}

	String version = null;
	for (int i = 0; i < pbc.length; i++) {
		try {
			BlockingClient bc = pbc[i].getBlockingClient();
			if (bc == null) {
				throw new TimeoutException("we do not have any client[bc] to connect to server!");
			}

			version = getVersion(bc);

			map.put(pbc[i].getSocketBasedHost().getInetSocketAddress(), version);
		} catch (IOException e) {
			if (pbc != null) {
				logger.log(Level.WARNING, "We had an ioerror will close client! " + e, e);
				pbc[i].close();
			}
		} finally {
			blockingClientPool.returnBlockingClient(pbc[i]);
			pbc[i] = null;
		}
	}

	return map;
}
 

import org.quickserver.net.client.BlockingClient; //导入依赖的package包/类
public void run() {
	logger.log(Level.FINE, "start thread {0}", getName());
	
	byte data[];
	while(true) {
		try	{
			if(init==false) {
				synchronized(lock) {
					lock.wait();
				}
				
				if(stopThead) {
					logger.log(Level.FINE, "stop thread {0}", getName());
					return;
				} else {
					continue;
				}
			}
			
			data = BlockingClient.readInputStream(bin);
			if(data==null) {
				init = false;
				logger.fine("got eof from remote pipe");
				handler.closeConnection();
			} else {
				interfaceServer.getStats().getOutByteCount().addAndGet(data.length);
				handler.sendClientBinary(data);
				
				if(logText) {
					logger.log(Level.FINE, "S:Text: {0}", new String(data));
				}
				if(logHex) {
					logger.log(Level.FINE, "S:Hex : {0}", hexencode(data));
				}
			}
		} catch(Exception e) {
			if(interfaceServer!=null) {
				interfaceServer.getStats().getConErrorCount().incrementAndGet();
			}
			init = false;
			if(closed==false) {
				logger.log(Level.WARNING, "Error in data thread : "+e, e);
			} else {
				//logger.log(Level.FINEST, "Error after connection was closed in data thread : {0}", e);
			}
			//e.printStackTrace();
		}
	}//end of while
}
 

import org.quickserver.net.client.BlockingClient; //导入依赖的package包/类
private CASValue readDataOutCAS(String key, String data) throws TimeoutException {
	long casUnique = 0;

	ClientInfo ci = new ClientInfo();
	ci.setClientKey(key);

	PooledBlockingClient pbc = null;

	try {
		pbc = blockingClientPool.getBlockingClient(ci);
		if (pbc == null) {
			throw new TimeoutException("rdo: we do not have any client[pbc] to connect to server!");
		}

		BlockingClient bc = pbc.getBlockingClient();
		if (bc == null) {
			throw new TimeoutException("we do not have any client[bc] to connect to server!");
		}

		bc.sendBytes(data, charset);
		String resMain = bc.readCRLFLine();

		if (resMain == null) {
			throw new TimeoutException("we got null reply!");
		}

		/*
		 VALUE <key> <flags> <bytes> [<cas unique>]\r\n
		 <data block>\r\n
		 END\r\n
		 */

		if (resMain.startsWith("VALUE ")) {
			String cmdData[] = resMain.split(" ");
			if (cmdData.length < 4) {
				return null;
			}
			int flag = Integer.parseInt(cmdData[2]);
			int bytes = Integer.parseInt(cmdData[3]);


			if (cmdData.length >= 5) {
				casUnique = Long.parseLong(cmdData[4]);
			}

			byte[] dataBuff = bc.readBytes(bytes);

			//read the footer 7 char extra \r\nEND\r\n
			bc.readBytes(7);

			if (dataBuff == null) {
				throw new TimeoutException("we don't have data!");
			}

			if (flag == FLAGS_GENRIC_STRING) {
				return new CASValue(casUnique, new String(dataBuff, charset));
			} else {
				return new CASValue(casUnique, retriveObject(dataBuff));
			}
		} else if (resMain.equals("END")) {
			return null;
		} else {
			logger.log(Level.WARNING, "unknown res got! : {0}", resMain);
			throw new TimeoutException("unknown res got! : " + resMain);
		}
	} catch (IOException e) {
		if (pbc != null) {
			logger.log(Level.WARNING, "We had an ioerror will close client! " + e, e);
			pbc.close();
		}
           if(e instanceof TimeoutException) {
               throw (TimeoutException) e;
           } else {
               throw new TimeoutException("We had ioerror " + e);
           }			
	} finally {
		if (pbc != null) {
			blockingClientPool.returnBlockingClient(pbc);
		}
	}
}
 

import org.quickserver.net.client.BlockingClient; //导入依赖的package包/类
private String sendCmdOut(String key, String data) throws TimeoutException {
	ClientInfo ci = new ClientInfo();
	ci.setClientKey(key);

	PooledBlockingClient pbc = null;

	try {
		pbc = blockingClientPool.getBlockingClient(ci);
		if (pbc == null) {
			throw new TimeoutException("cmo: we do not have any client[pbc] to connect to server!");
		}

		BlockingClient bc = pbc.getBlockingClient();
		if (bc == null) {
			throw new TimeoutException("we do not have any client[bc] to connect to server!");
		}

		bc.sendBytes(data, charset);

		String resMain = bc.readCRLFLine();
		if (resMain == null) {
			throw new TimeoutException("we got null reply!");
		}

		return resMain;
	} catch (IOException e) {
		if (pbc != null) {
			logger.log(Level.WARNING, "We had an ioerror will close client! " + e, e);
			pbc.close();
		}
           if(e instanceof TimeoutException) {
               throw (TimeoutException) e;
           } else {
               throw new TimeoutException("We had ioerror " + e);
           }			
	} finally {
		if (pbc != null) {
			blockingClientPool.returnBlockingClient(pbc);
		}
	}
}
 

import org.quickserver.net.client.BlockingClient; //导入依赖的package包/类
public BlockingClient getBlockingClient() {
	return blockingClient;
}
 

import org.quickserver.net.client.BlockingClient; //导入依赖的package包/类
public void setBlockingClient(BlockingClient blockingClient) {
	this.blockingClient = blockingClient;
}
 

import org.quickserver.net.client.BlockingClient; //导入依赖的package包/类
public BlockingClient createBlockingClient(SocketBasedHost host); 

import org.quickserver.net.client.BlockingClient; //导入依赖的package包/类
public boolean closeBlockingClient(BlockingClient blockingClient); 

import org.quickserver.net.client.BlockingClient; //导入依赖的package包/类
public boolean sendNoOp(BlockingClient blockingClient);