cmppserver.java

短信网关发送接受平台。

import java.lang.*;
import java.net.*;
import java.io.*;

import CMPPLog;
import CMPPException;

import CMPPUtility;

import CMPPThread;

import CMPPSynchronizedIO;
import CMPPAsynchronizedIO;

import CMPPConnect;
import CMPPConnectResponse;

import CMPPTerminate;
import CMPPTerminateResponse;

import CMPPActiveTest;
import CMPPActiveTestResponse;

import CMPPServerRequest;
import CMPPServerResponse;

public class CMPPServer extends CMPPThread
{
	final static int DEFAULT_ACTIVETEST_TIMEOUT	= 30000;
	final static int DEFAULT_DELIVER_TIMEOUT	= 20000;
	final static int DEFAULT_STATUSREPORT_TIMEOUT	= 50000;
	
	final static int MAX_ERROR_COUNT	= 20;
	
	//连接Socket
	Socket m_sktServer = null;
	
	//通讯层
	CMPPSynchronizedIO m_synio = null;
	CMPPAsynchronizedIO m_asynio = null;

	public CMPPServer(Socket sktServer)
		throws IOException, CMPPException
	{
		if(sktServer == null)
		{
			throw new CMPPException("CMPPServer.CMPPServer : null socket !");
		}
		m_sktServer = sktServer;
		
		//生成一个同步IO
		m_synio = new CMPPSynchronizedIO(m_sktServer);
		
		//生成一个异步IO处理器
		m_asynio = new CMPPAsynchronizedIO(m_synio);
	}
	
	public void startup()
	{
		CMPPLog.log("CMPPServer.startup : cmpp server startup !",
			CMPPLog.LOG_CMPP_SERVER);
			
		m_asynio.startup();
		super.startup();
	}
	
	public void shutdown()
	{
		super.shutdown();

		CMPPLog.log("CMPPServer.shutdown : cmpp server shutdown !",
			CMPPLog.LOG_CMPP_SERVER);
	}
	
	public void run()
	{
		boolean bAuthenticated = false;
		
		long lActiveTestStartTime = System.currentTimeMillis();
		long lDeliverStartTime = System.currentTimeMillis();
		long lStatusReportStartTime = System.currentTimeMillis();
		
		try
		{
			m_nStatus = THREAD_RUNNING;
			while(isRunning() && m_asynio.isRunning())
			{
				//检查异步IO的错误状况
				if(m_asynio.m_nErrorCount > MAX_ERROR_COUNT)
				{
					//退出连接
					throw new CMPPException("CMPPServer.run : too much asynchronized io errors !");
				}
				
				//CMPP定时检测
				if((System.currentTimeMillis() - lActiveTestStartTime) > DEFAULT_ACTIVETEST_TIMEOUT)
				{
					lActiveTestStartTime = System.currentTimeMillis();

					//异步activetest
					CMPPServerRequest request = new CMPPServerRequest(m_synio,m_asynio,null);
					request.activetest();
				}
				
				if((System.currentTimeMillis() - lDeliverStartTime) > DEFAULT_DELIVER_TIMEOUT)
				{
					lDeliverStartTime = System.currentTimeMillis();
					
					//异步deliver
					CMPPServerRequest request = new CMPPServerRequest(m_synio,m_asynio,null);
					request.deliver();
				}
				
				if((System.currentTimeMillis() - lStatusReportStartTime) > DEFAULT_STATUSREPORT_TIMEOUT)
				{
					lStatusReportStartTime = System.currentTimeMillis();
					
					//异步report
					CMPPServerRequest request = new CMPPServerRequest(m_synio,m_asynio,null);
					request.report();
				}
				
				//查看数据包
				CMPPPacket packet = m_asynio.peer();
				if(packet != null && CMPPCommandID.isRequest(packet.command_id))
				{
					//读取数据包。
					packet = m_asynio.read();

					//服务器异步响应
					CMPPServerResponse response = new CMPPServerResponse(m_synio,m_asynio,packet);
					response.startup();
				}
				
				if(m_asynio.m_bTerminate)
				//通讯需要中断
				{
					break;
				}
			}
		}
		catch(Exception e)
		{
			CMPPLog.log(e.getMessage(),
				CMPPLog.LOG_CMPP_SERVER | LogRequest.LOG_EXCEPTION);
			CMPPLog.log("CMPPServer.run : unexpected exit !",
				CMPPLog.LOG_CMPP_SERVER | LogRequest.LOG_EXCEPTION);
		}
		
		//关闭异步IO
		m_asynio.shutdown();
		//关闭同步IO
		m_synio.close();
		
		try
		{
			//关闭socket
			m_sktServer.close();
		}
		catch(Exception e)
		{
			CMPPLog.log(e.getMessage(),
				CMPPLog.LOG_CMPP_SERVER | LogRequest.LOG_EXCEPTION);
		}
		
		m_nStatus = THREAD_STOPPED;
		CMPPLog.log("CMPPServer.run : thread stopped !",
			CMPPLog.LOG_CMPP_SERVER | CMPPLog.LOG_EXCEPTION);
	}

	public static void main(String[] args)
	{
		System.out.println("www.simpleteam.com CMPPServer Simulator (ver 1.2) free released !");
		System.out.println("\tSupported Command List:");
		System.out.println("\t\tconnect -- receive connect request from CMPPClient.");
		System.out.println("\t\tsubmit -- receive submit request from CMPPClient.");
		System.out.println("\t\tcancel -- receive cancel request from CMPPClient.");
		System.out.println("\t\tquery -- receive query request from CMPPClient.");
		System.out.println("\t\tactivetest -- receive activetest request from CMPPClient.");
		System.out.println("\t\tterminate -- receive terminate request from CMPPClient.");
		System.out.println("\t\tdeliver -- send deliver to CMPPClient.");
		System.out.println("\tPress Ctrl+C to stop it !");
		
		try
		{
			//打开日志文件
			FileLog.openLog("server.log");
			//CMPP日志请求
			//CMPPLog.logRequests(CMPPLog.LOG_EXCEPTION | CMPPLog.LOG_ISVALID_METHOD | CMPPLog.LOG_CMPP_CLIENT);
			CMPPLog.logRequests(CMPPLog.LOG_ALL);

			
			//生成一个服务器端侦听Socket
			ServerSocket sktListen = new ServerSocket(7809);
			CMPPLog.log("CMPPServer.main : waiting on port 7809",
				CMPPLog.LOG_CMPP_SERVER);
			
			CMPPServer server = null;
			while(true)
			{
				//等待接收请求
				Socket sktServer = sktListen.accept();
				CMPPLog.log("CMPPServer.main : client accepted ",
					CMPPLog.LOG_CMPP_SERVER);
				
				//生成一个服务处理器
				server = new CMPPServer(sktServer);
				server.startup();
			}
		}
		catch(Exception e)
		{
			CMPPLog.log(e.getMessage(),
				CMPPLog.LOG_CMPP_SERVER | LogRequest.LOG_EXCEPTION);
			CMPPLog.log("CMPPServer.main : unexpected exit !",
				CMPPLog.LOG_CMPP_SERVER | LogRequest.LOG_EXCEPTION);
		}

		CMPPLog.log("CMPPServer.main : cmpp server shutdown!",
			CMPPLog.LOG_CMPP_SERVER);

		//关闭日志文件			
		FileLog.closeLog();
	}
}