public override async ValueTask <Connection?> AcceptConnectionAsync(IConnectionProperties?options = null, CancellationToken cancellationToken = default)
{
Connection?baseConnection = await BaseListener.AcceptConnectionAsync(options, cancellationToken).ConfigureAwait(false);
if (baseConnection == null)
{
return(null);
}
SslStream?stream = null;
try
{
stream = new SslStream(baseConnection.Stream, leaveInnerStreamOpen: false);
await stream.AuthenticateAsServerAsync(_sslOptions, cancellationToken).ConfigureAwait(false);
return(new SslConnection(baseConnection, stream));
}
catch
{
if (stream != null)
{
await stream.DisposeAsync().ConfigureAwait(false);
}
await baseConnection.DisposeAsync(cancellationToken).ConfigureAwait(false);
throw;
}
}
/// <summary>
/// 异步监听回调
/// </summary>
/// <param name="ar"></param>
private void Result(IAsyncResult ar)
{
if (BaseListener == null || !BaseListener.IsListening)
{
return;
}
//当接收到请求后程序流会走到这里
//继续异步监听
BaseListener.BeginGetContext(Result, null);
GUID = Guid.NewGuid().ToString();
//获得context对象
var context = BaseListener.EndGetContext(ar);
var request = context.Request;
var response = context.Response;
////如果是js的ajax请求，还可以设置跨域的ip地址与参数
//context.Response.AppendHeader("Access-Control-Allow-Origin", "*"); //后台跨域请求，通常设置为配置文件
//context.Response.AppendHeader("Access-Control-Allow-Headers", "ID,PW"); //后台跨域参数设置，通常设置为配置文件
//context.Response.AppendHeader("Access-Control-Allow-Method", "post"); //后台跨域请求设置，通常设置为配置文件
response.ContentType = "text/plain;charset=UTF-8"; //告诉客户端返回的ContentType类型为纯文本格式，编码为UTF-8
response.AddHeader("Content-type", "text/plain"); //添加响应头信息
response.ContentEncoding = Encoding.UTF8;
//定义返回客户端的信息，当请求为POST方式时返回处理过的信息，否则判断可能为网页访问、返回指定消息
string returnObj = request.HttpMethod == "POST" && request.InputStream != null?HandleRequest(request, response) : WebExplorerMessage;
var returnByteArr = Encoding.UTF8.GetBytes(returnObj); //设置客户端返回信息的编码
//把处理信息返回到客户端
try { using (var stream = response.OutputStream) { stream.Write(returnByteArr, 0, returnByteArr.Length); } }
catch (Exception ex) { LastErrorMessage = $"网络蹦了：{ex.ToString()}"; }
}
/// <summary>
/// 停止监听器
/// </summary>
public int Stop()
{
int result = 1;
try
{
if (BaseListener != null)
{
BaseListener.Stop();
BaseListener = null;
}
_raiser.Stop();
ServiceStateChanged?.BeginInvoke(this, new ServiceStateEventArgs($"HTTP监听服务{Name}已停止", ServiceState.Stopped), null, null);
}
catch (ObjectDisposedException e)
{
LastErrorMessage = $"HTTP监听服务{Name}已被释放：{e.Message}";
result = 0;
BaseListener = null;
}
catch (Exception e)
{
LastErrorMessage = $"HTTP监听服务{Name}停止过程中出现错误：{e.Message}";
result = 0;
throw;
}
return(result);
}
/// <summary>
/// 启动监听器
/// </summary>
public int Start()
{
int result = 1;
try
{
if (BaseListener == null)
{
BaseListener = new HttpListener(); //提供一个简单的、可通过编程方式控制的 HTTP 协议侦听器。此类不能被继承。
//配置监听地址。+代表本机可能的IP，如localhost、127.0.0.1、192.168.199.X(本机IP)等，假如失败则以管理员方式启动
//string address = $"http://{IpAddress}:{Port}/web/";
string address = $"http://+:{Port}{Suffix}";
BaseListener.Prefixes.Clear();
BaseListener.Prefixes.Add(address); //定义url及端口号，通常设置为配置文件
BaseListener.Start();
Name = address;
}
//异步监听客户端请求，当客户端的网络请求到来时会自动执行Result委托
//该委托没有返回值，有一个IAsyncResult接口的参数，可通过该参数获取context对象
BaseListener.BeginGetContext(Result, null);
_raiser.Run();
if (BaseListener.IsListening)
{
ServiceStateChanged?.BeginInvoke(this, new ServiceStateEventArgs($"HTTP监听服务{Name}已启动", ServiceState.Started), null, null);
}
}
catch (Exception e)
{
LastErrorMessage = $"HTTP监听服务{Name}启动过程中出现错误：{e.Message}";
result = 0;
Stop();
//throw;
}
return(result);
}
private BaseListener ConnectPeer(BaseListener listener, ServerInfo server)
{
var peer = new PhotonPeer(listener, ConnectionProtocol.Udp);
peer.Connect(string.Format("{0}:{1}", server.ip, server.port), server.appName);
listener.SetPeer(peer);
return(listener);
}
public override async ValueTask <Connection?> AcceptConnectionAsync(IConnectionProperties?options = null, CancellationToken cancellationToken = default)
{
Connection?con = await BaseListener.AcceptConnectionAsync(options, cancellationToken).ConfigureAwait(false);
if (con == null)
{
return(con);
}
return(new FilteringConnection(con, new WriteBufferingStream(con.Stream)));
}
public void AddListener(Action <ISignal, object[]> callback)
{
foreach (Delegate del in BaseListener.GetInvocationList())
{
Action <ISignal, object[]> action = (Action <ISignal, object[]>)del;
if (callback.Equals(action))
{
return;
}
}
BaseListener += callback;
}
public void AddListener(Action <IBaseSignal, object[]> callback)
{
foreach (Delegate del in BaseListener.GetInvocationList())
{
Action <IBaseSignal, object[]> action = (Action <IBaseSignal, object[]>)del;
if (callback.Equals(action)) //If this callback exists already, ignore this addlistener
{
return;
}
}
BaseListener += callback;
}
public static string GetRules(string code)
{
var ais = new AntlrInputStream(code);
//var lexer = new gramLexer(ais);
var lexer = new SASLibnamesLexer(ais);
var ts = new UnbufferedTokenStream(lexer);
//var parser = new gramParser(ts);
var parser = new SASLibnamesParser(ts);
//var tree = parser.compileUnit();
var tree = parser.program();
var listener = new BaseListener <SASLibnamesParser>();
var walker = new ParseTreeWalker();
walker.Walk(listener, tree);
return(listener.GetRules());
}
public async Task Run(int backlog)
{
stopping = false;
EndPoint ep;
try {
BaseListener.Server.NoDelay = true;
BaseListener.Start(backlog);
ep = BaseListener.LocalEndpoint;
} catch (Exception e) {
Logger.error($"starting on {BaseListener.LocalEndpoint}: {e.Message}");
return;
}
if (LogInfo)
{
Logger.info($"listening on {ep}");
}
while (true)
{
TcpClient cli = null;
try {
try {
cli = await BaseListener.AcceptTcpClientAsync().CAF();
NaiveUtils.ConfigureSocket(cli.Client);
} catch (Exception) when(stopping)
{
if (LogInfo)
{
Logger.info($"stopped on {ep}");
}
return;
}
Accepted?.Invoke(cli);
} catch (Exception e) {
Logger.exception(e, Logging.Level.Error, ep?.ToString());
}
}
}
public void Stop()
{
//Logging.info($"stopping listening on {BaseListener.LocalEndpoint}");
stopping = true;
BaseListener.Stop();
}
