public TcpConnection(Socket socket, SocketSetting setting, IBufferPool receiveDataBufferPool, Action <ITcpConnection, byte[]> messageArrivedHandler, Action <ITcpConnection, SocketError> connectionClosedHandler)
{
Ensure.NotNull(socket, "socket");
Ensure.NotNull(setting, "setting");
Ensure.NotNull(receiveDataBufferPool, "receiveDataBufferPool");
Ensure.NotNull(messageArrivedHandler, "messageArrivedHandler");
Ensure.NotNull(connectionClosedHandler, "connectionClosedHandler");
_id = Guid.NewGuid();
_socket = socket;
_setting = setting;
_receiveDataBufferPool = receiveDataBufferPool;
_localEndPoint = socket.LocalEndPoint;
_remotingEndPoint = socket.RemoteEndPoint;
_messageArrivedHandler = messageArrivedHandler;
_connectionClosedHandler = connectionClosedHandler;
_sendSocketArgs = new SocketAsyncEventArgs();
_sendSocketArgs.AcceptSocket = socket;
_sendSocketArgs.Completed += OnSendAsyncCompleted;
_receiveSocketArgs = new SocketAsyncEventArgs();
_receiveSocketArgs.AcceptSocket = socket;
_receiveSocketArgs.Completed += OnReceiveAsyncCompleted;
_receiveSocketArgs.UserToken = new ConcurrentQueue <ReceivedData>();
_framer = DependencyManage.Resolve <IMessageFramer>();
_framer.RegisterMessageArrivedCallback(OnMessageArrived);
TryReceive();
TrySend();
}
public NRpcServer(IPAddress ip, int port)
{
_iPEndPoint = new IPEndPoint(ip, port);
_routeCoordinator = DependencyManage.Resolve <ICoordinatorFactory>().Create();
_gloabFilterList = new List <IServerFilter>();
}
public ClientMethodCaller(Type proxyType)
{
_proxyType = proxyType;
_methodCallSerializer = DependencyManage.Resolve <IMethodCallSerializer>();
_responseSerailizer = DependencyManage.Resolve <IResponseSerailizer>();
_configProvider = DependencyManage.Resolve <IConfigProvider>();
_rpcMonitor = DependencyManage.Resolve <IRpcMonitor>();
}
/// <summary>
/// 请求处理
/// </summary>
/// <param name="remotingRequest"></param>
/// <returns></returns>
public RemotingResponse HandleRequest(RemotingRequest remotingRequest)
{
var requestMethodInfo = DependencyManage.Resolve <IMethodCallSerializer>().Deserialize <RpcMethodCallInfo>(remotingRequest.Body);
var classType = ServerAssemblyUtil.GetType(requestMethodInfo.TypeName);
using (var scope = DependencyManage.BeginScope())
{
var obj = scope.ServiceProvider.GetService(classType);
MethodInfo executeMethodInfo = null;
try
{
LogUtil.InfoFormat("Begin Deal Rpc Request:{0}-{1}", requestMethodInfo.TypeName, requestMethodInfo.MethodName);
executeMethodInfo = ServerAssemblyUtil.GetMethod(requestMethodInfo.MethodName, classType) as MethodInfo;
if (executeMethodInfo == null)
{
_rpcMonitor.AddError(new RpcMonitorRequestErrorInfo(requestMethodInfo, remotingRequest, "Not Found Method"));
return(remotingRequest.CreateNotFoundResponse($"{requestMethodInfo.TypeName},{requestMethodInfo.MethodName}"));
}
else
{
var delegateType = executeMethodInfo.GetMethodReturnType();
OnActionExecuting(executeMethodInfo, requestMethodInfo.Parameters);
var executeResult = executeMethodInfo.Invoke(obj, requestMethodInfo.Parameters);
RemotingResponse remotingResponse;
if (delegateType == MethodType.SyncAction)
{
remotingResponse = remotingRequest.CreateSuccessResponse(ResponseUtil.NoneBodyResponse);
}
else if (delegateType == MethodType.SyncFunction)
{
remotingResponse = remotingRequest.CreateSuccessResponse(GetBody(executeResult, executeMethodInfo));
}
else if (delegateType == MethodType.AsyncAction)
{
var task = (Task)executeResult;
task.Wait();
remotingResponse = remotingRequest.CreateSuccessResponse(ResponseUtil.NoneBodyResponse);
}
else
{
var resultType = executeMethodInfo.ReturnType.GetGenericArguments()[0];
var mi = HandleAsyncMethodInfo.MakeGenericMethod(resultType);
var result = mi.Invoke(this, new[] { executeResult });
remotingResponse = remotingRequest.CreateSuccessResponse(GetBody(result, executeMethodInfo));
}
LogUtil.InfoFormat("Rpc Method Dealed:{0}-{1}", requestMethodInfo.TypeName, requestMethodInfo.MethodName);
OnActionExecuted(executeMethodInfo);
return(remotingResponse);
}
}
catch (Exception e)
{
HandleException(executeMethodInfo, e);
_rpcMonitor.AddError(new RpcMonitorRequestErrorInfo(requestMethodInfo, remotingRequest, e));
return(remotingRequest.CreateDealErrorResponse());
}
}
}
private static ILogger GetLogger(string loggerName = null)
{
var loggerFactory = DependencyManage.Resolve <ILoggerFactory>();
if (string.IsNullOrWhiteSpace(loggerName))
{
loggerName = "NetCoreRpc.Public";
}
return(loggerFactory.CreateLogger(loggerName));
}
public static SocketRemotingClient GetClient(Type classType)
{
var className = classType.FullName;
//TODO 根据类名字动态获取IP端口信息
var remoteEndPointConfigProvider = DependencyManage.Resolve <IRemoteEndPointConfigProvider>();
var config = remoteEndPointConfigProvider.GetConfig();
var ipEndPoint = config.GetEndPoint(classType.FullName);
var clientPool = ClientPoolList.GetValue(ipEndPoint, () =>
{
return(new ClientPool(config.MaxClientPoolCount, ipEndPoint));
});
return(clientPool.GetCilent());
}
private static void Main(string[] args)
{
DependencyManage.UseAutofacContainer().UseNRpc().UseMongoDBMonitor(() =>
{
return(new MonogoDbConfig("mongodb://*****:*****@192.168.100.125:27017", "Rpc_Monitor"));
});
NRpcConfigWatcher.Install();
Console.WriteLine("Welcome to use NetCoreRpc!");
Console.WriteLine("Input exit to exit");
var str = Console.ReadLine();
while (!string.Equals(str, "exit", StringComparison.OrdinalIgnoreCase))
{
Send();
str = Console.ReadLine();
}
}
public SocketRemotingClient(EndPoint serverEndPoint, SocketSetting setting = null, EndPoint localEndPoint = null)
{
Ensure.NotNull(serverEndPoint, "serverEndPoint");
_serverEndPoint = serverEndPoint;
_localEndPoint = localEndPoint;
_setting = setting ?? new SocketSetting();
_receiveDataBufferPool = new BufferPool(_setting.ReceiveDataBufferSize, _setting.ReceiveDataBufferPoolSize);
_clientSocket = new ClientSocket(_serverEndPoint, _localEndPoint, _setting, _receiveDataBufferPool, HandleServerMessage);
_responseFutureDict = new ConcurrentDictionary <long, ResponseFuture>();
_replyMessageQueue = new BlockingCollection <byte[]>(new ConcurrentQueue <byte[]>());
_responseHandlerDict = new Dictionary <int, IResponseHandler>();
_remotingServerMessageHandlerDict = new Dictionary <int, IRemotingServerMessageHandler>();
_connectionEventListeners = new List <IConnectionEventListener>();
_scheduleService = DependencyManage.Resolve <IScheduleService>();
RegisterConnectionEventListener(new ConnectionEventListener(this));
}
private static void Main(string[] args)
{
var builder = new ConfigurationBuilder().SetBasePath(Path.Combine(AppContext.BaseDirectory)).AddJsonFile("NetCoreRpc.json", optional: true);
Configuration = builder.Build();
var servicesProvider = BuildDi();
DependencyManage.SetServiceProvider(servicesProvider, Configuration);
Console.WriteLine("Welcome to use NetCoreRpc!");
Console.WriteLine("Input exit to exit");
var str = Console.ReadLine();
while (!string.Equals(str, "exit", StringComparison.OrdinalIgnoreCase))
{
Send();
str = Console.ReadLine();
}
}
private static void Main(string[] args)
{
Console.WriteLine("请输入监听端口:");
var strPort = Console.ReadLine();
DependencyManage.UseAutofacContainer().UseNRpc().RegisterType <IStudentApplication, StudentApplication>().UseMongoDBMonitor(() =>
{
return(new MonogoDbConfig("mongodb://*****:*****@192.168.100.125:27017", "Rpc_Monitor"));
});;
NRpcServer nrpcServer = new NRpcServer(int.Parse(strPort));
nrpcServer.RegisterServerType(typeof(IStudentApplication));
nrpcServer.Start();
Console.WriteLine("Welcome to use NetCoreRpc!");
Console.WriteLine("Input exit to exit");
var str = Console.ReadLine();
while (!string.Equals(str, "exit", StringComparison.OrdinalIgnoreCase))
{
str = Console.ReadLine();
}
nrpcServer.ShutDown();
}
private static void Main(string[] args)
{
Console.WriteLine("请输入监听端口:");
var strPort = Console.ReadLine();
var builder = new ConfigurationBuilder()
.SetBasePath(Path.Combine(AppContext.BaseDirectory)).AddJsonFile("NetCoreRpc.json", optional: true);
Configuration = builder.Build();
var servicesProvider = BuildDi();
DependencyManage.SetServiceProvider(servicesProvider, Configuration);
NRpcServer nrpcServer = new NRpcServer(int.Parse(strPort));
nrpcServer.Start("NetCoreRpc.Application");
Console.WriteLine("Welcome to use NetCoreRpc!");
Console.WriteLine("Input exit to exit");
var str = Console.ReadLine();
while (!string.Equals(str, "exit", StringComparison.OrdinalIgnoreCase))
{
str = Console.ReadLine();
}
nrpcServer.ShutDown();
}
/// <summary>
/// 使用默认的任务调度
/// </summary>
/// <param name="containerManager"></param>
/// <returns></returns>
public static DependencyManage UseDefaultSchedule(this DependencyManage dependencyManage)
{
return(dependencyManage.RegisterType <IScheduleService, ScheduleService>());
}
/// <summary>
/// 使用socket
/// </summary>
/// <param name="containerManager"></param>
/// <returns></returns>
public static DependencyManage UseSocket(this DependencyManage dependencyManage)
{
return(dependencyManage.RegisterType <IMessageFramer, LengthPrefixMessageFramer>(lifeStyle: Dependency.LifeStyle.Transient));
}
public static DependencyManage UseDefaultConfigProvider(this DependencyManage dependencyManage)
{
return(dependencyManage.RegisterType <IConfigProvider, DefalutConfigProvider>());
}
public static DependencyManage UseDefaultLock(this DependencyManage dependencyManage)
{
return(dependencyManage.RegisterType <ILock, LocalLock>());
}
public static DependencyManage UseDefaultMethodSerializer(this DependencyManage containerManager)
{
return(containerManager.RegisterType <IMethodCallSerializer, RpcDefaultSerializer>());
}
public static DependencyManage UseDefaultMonitor(this DependencyManage serviceCollection)
{
return(serviceCollection.RegisterType <IRpcMonitor, DefaultRpcMonitor>());
}
public static DependencyManage UseDefaultSerializer(this DependencyManage containerManager)
{
return(containerManager.RegisterType <IBinarySerializer, DefaultBinarySerializer>());
}
public static DependencyManage UseDefaultResponseSerializer(this DependencyManage containerManager)
{
return(containerManager.RegisterType <IResponseSerailizer, ResponseSerializer>());
}
private byte[] GetBody(object obj, MethodInfo methodInfo)
{
return(DependencyManage.Resolve <IResponseSerailizer>().Serialize(obj, methodInfo));
}
/// <summary>
/// 使用Nlog
/// </summary>
/// <param name="containerManager"></param>
/// <returns></returns>
public static DependencyManage UseNlog(this DependencyManage dependencyManage)
{
return(dependencyManage.RegisterType <ILoggerFactory, NLoggerFactory>());
}
public ServerMethodCaller(List <IServerFilter> serverFilterList)
{
_serverFilterList = serverFilterList;
_rpcMonitor = DependencyManage.Resolve <IRpcMonitor>();
}
public static DependencyManage UseZKServerRoute(this DependencyManage dependencyManage)
{
return(dependencyManage.RegisterType <ICoordinatorFactory, ZkCoordinatorFactory>());
}
static RpcConfig()
{
_RouteCoordinator = DependencyManage.Resolve <ICoordinatorFactory>().Create();
}
public ClientPoolConnectionLister(SocketRemotingClient client, ClientPool clientPool)
{
_client = client;
_clientPool = clientPool;
_lock = DependencyManage.Resolve <ILock>();
}
public static DependencyManage UseMongoDBMonitor(this DependencyManage dependencyManage, Func <MonogoDbConfig> func)
{
MonogoDbConfig.SetConfig(func);
return(dependencyManage.RegisterType <IRpcMonitor, MongoMonitor>());
}
