// For recieving and sending replies to host as far as I can tell
private static bool ApiReceiver(SoapAPI api)
{
try
{
// Based on what myApi.MessageType is
switch (api.MessageType)
{
case MessageTypes.Request: // Did we recieve a request for a reply from the host?
OnRequest?.Invoke(api, new VmsRequestEventArgs
{
Request = new VmsCommand(api)
});
break;
case MessageTypes.Reply: // Did we recieve a reply from the host?
OnReply?.Invoke(api, new VmsReplyEventArgs
{
Reply = new VmsCommand(api)
});
break;
default:
break;
}
return(true);
}
catch (Exception ex)
{
//MessageBox.Show("Error: " + ex.ToString());
return(false);
}
}
public void ReadCallback(IAsyncResult ar)
{
var state = (HubState)ar.AsyncState;
var bytesRead = state.WorkSocket.EndReceive(ar);
if (bytesRead <= 0)
{
return;
}
bool recv;
try
{
recv = state.Receive(bytesRead);
}
catch (Exception e)
{
state.SendError(e);
recv = true;
}
if (recv)
{
OnRequest?.Invoke(this, state);
Send(state);
}
else
{
state.WorkSocket.BeginReceive(state.Buffer, state.BufferLen, Config.BufferSize, 0,
ReadCallback, state);
}
}
public async Task StartAsync()
{
try
{
HttpListener.Start();
isFinished = new ManualResetEvent(false);
logger?.LogInformation("HttpListener for requests on [{0}] running!", string.Join(", ", UriPrefixes));
while (!isFinished.WaitOne(0) && HttpListener.IsListening)
{
var ctx = await HttpListener.GetContextAsync();
Request request = new Request(ctx);
Response response = new Response(ctx);
// logger?.LogDebug("{0}: {1} {2}", DateTime.Now, request.Method, request.Endpoint);
Console.WriteLine("HttpListener {0}: {1} {2}", DateTime.Now, request.Method, request.Endpoint);
OnRequest?.Invoke(request, response);
}
}
catch (Exception e)
{
logger?.LogError("HttpListener StartAsync Error:{0}", e.Message);
}
finally
{
HttpListener = null;
}
logger?.LogInformation("HttpListener for requests on {0} FINISHED", string.Join(", ", UriPrefixes));
}
public static object Request(RequestType what, RequestProperty want)
{
object r;
r = OnRequest?.Invoke(what, want);
return(r);
}
private async void ListenAsyncImpl()
{
//if this method fails due to an access denied error, run visual studio as an administrator
_listener.Start();
while (_listener.IsListening)
{
HttpListenerContext ctx = null;
try
{
ctx = await _listener.GetContextAsync().ConfigureAwait(false);
}
catch (HttpListenerException e)
{
OnError?.Invoke(this, e);
}
if (ctx == null)
{
return;
}
OnRequest?.Invoke(this, ctx);
}
}
/// <summary>
/// This method is called to process an incoming payload.
/// </summary>
/// <param name="rq">The message to process.</param>
/// <param name="responses">The return path for the message.</param>
public virtual async Task ProcessRequest(TransmissionPayload rq, List <TransmissionPayload> responses)
{
int start = StatisticsInternal.ActiveIncrement();
try
{
var header = rq.Message.ToServiceMessageHeader();
H handler;
if (!SupportedResolve(header, out handler))
{
OnRequestUnresolved?.Invoke(this, rq);
throw new CommandNotSupportedException(rq.Id, header, GetType());
}
OnRequest?.Invoke(this, rq);
//Call the registered command.
await handler.Execute(rq, responses);
}
catch (Exception)
{
StatisticsInternal.ErrorIncrement();
//throw any errors back out to the dispatcher.
throw;
}
finally
{
StatisticsInternal.ActiveDecrement(start);
}
}
/// <summary>
/// Process a request.
/// </summary>
/// <param name="context"></param>
private void Process(HttpListenerContext context)
{
OnRequest?.Invoke(context.Request);
var filename = context.Request.Url.AbsolutePath.Substring(1);
if (string.IsNullOrEmpty(filename))
{
foreach (var indexFile in indexFiles)
{
if (!File.Exists(Path.Combine(root, indexFile)))
{
continue;
}
filename = indexFile;
break;
}
}
filename = Path.Combine(root, filename);
string mime;
if (File.Exists(filename) && mimeTypeMappings.TryGetValue(Path.GetExtension(filename), out mime))
{
try
{
Stream input = new FileStream(filename, FileMode.Open);
context.Response.ContentType = mime;
context.Response.ContentLength64 = input.Length;
context.Response.AddHeader("Date", DateTime.Now.ToString("r"));
context.Response.AddHeader("Last-Modified", File.GetLastWriteTime(filename).ToString("r"));
int nbytes;
byte[] buffer = new byte[1024 * 16];
while ((nbytes = input.Read(buffer, 0, buffer.Length)) > 0)
{
context.Response.OutputStream.Write(buffer, 0, nbytes);
}
input.Close();
context.Response.StatusCode = (int)HttpStatusCode.OK;
context.Response.OutputStream.Flush();
}
catch
{
context.Response.StatusCode = (int)HttpStatusCode.InternalServerError;
}
}
else
{
context.Response.StatusCode = (int)HttpStatusCode.NotFound;
}
context.Response.OutputStream.Close();
}
protected override void ProcessRequest(HttpRequest request)
{
OnRequest?.Invoke(request);
if (OnRequest.GetInvocationList().Length == 0)
{
request.Respond("This request is not handled.", System.Net.HttpStatusCode.BadRequest);
}
}
public TransferAnswer SendRequest(TransferRequest request)
{
var src = request.Source;
var dst = request.Destination;
OnRequest?.Invoke(this, EventArgs.Empty);
return(new TransferAnswer());
}
protected override Task Process(HttpListenerContext context, ILogger logger, CancellationToken cancellation)
{
if (OnRequest != null)
{
return(OnRequest.Invoke(context, cancellation));
}
return(base.Process(context, logger, cancellation));
}
private void Listen()
{
Console.WriteLine("Started listening on {0}", Address);
while (listener.IsListening)
{
var context = listener.GetContext();
OnRequest?.Invoke(this, context);
}
Console.WriteLine("Stopped listening");
}
/// <summary>收到客户端发来的数据。子类可通过重载该方法来修改数据</summary>
/// <param name="e"></param>
protected override void OnReceive(ReceivedEventArgs e)
{
// 解析请求头
var stream = e.Packet.GetStream();
var entity = HttpHeader.Read(stream, HttpHeaderReadMode.Request);
if (entity == null)
{
base.OnReceive(e);
return;
}
WriteLog("{3}请求：{0} {1} [{2}]", entity.Method, entity.Url, entity.ContentLength, ID);
Request = entity;
OnRequest?.Invoke(this, e);
var pxy = Host as HttpReverseProxy;
var host = entity.Url.IsAbsoluteUri ? entity.Url.Host : pxy.RemoteServer.Host;
RemoteHost = host;
RawHost = entity.Host;
entity.Host = host;
// 引用
var r = entity.Referer;
if (!String.IsNullOrEmpty(r))
{
var ri = new Uri(r, UriKind.RelativeOrAbsolute);
if (ri.IsAbsoluteUri && ri.Authority == RawHost)
{
r = r.Replace(RawHost, host);
entity.Referer = r;
}
}
//// 取消压缩
//var key = "Accept-Encoding";
//if (entity.Headers.ContainsKey(key)) entity.Headers.Remove(key);
// 重新构造请求
var ms = new MemoryStream();
entity.Write(ms);
stream.CopyTo(ms);
ms.Position = 0;
//e.Stream = ms;
e.Packet = ms.ToArray();
base.OnReceive(e);
}
/// <summary>
/// 监听到请求时
/// </summary>
private void ListenedRequest(IAsyncResult result)
{
var context = listener.EndGetContext(result);
if (OnRequest != null)
{
try
{
OnRequest.Invoke(context);
}
catch { }
}
listener.BeginGetContext(ListenedRequest, null);
}
private void SendCallback(IAsyncResult ar)
{
var state = (AgentState)ar.AsyncState;
try
{
state.WorkSocket.EndSend(ar);
SendDone.Set();
OnRequest?.Invoke(this, state);
}
catch (Exception e)
{
Abort(state, e);
}
}
private async Task ProcessTranslation(HttpListenerRequest req, HttpListenerResponse resp)
{
string?japanese = GetTextParam(req);
OnRequest?.Invoke(req.RemoteEndPoint, japanese);
if (japanese == null)
{
return;
}
string?korean = await Translator.Translate(japanese ?? "").ConfigureAwait(false);
resp.ContentType = "text/plain; charset=utf-8";
byte[] buf = Encoding.UTF8.GetBytes(korean);
resp.ContentLength64 = buf.LongLength;
await resp.OutputStream.WriteAsync(buf, 0, buf.Length);
}
internal void OnRequestEvent(Request req)
{
if (OnRequest != null)
{
try
{
OnRequest.Invoke(req, this);
}
catch (Exception ex)
{
Trace.WriteLine("HTTP/Server/OnRequest Unhandled Exception: " + ex);
}
}
else
{
throw new Exception("HTTP Request Handler OnRequest Not Attached.");
}
}
// Create and configure our web server.
private WebServer CreateWebServer(string url, string origins, string headers, string methods)
{
var server = new WebServer(o => o
.WithUrlPrefix(url)
.WithMode(HttpListenerMode.EmbedIO)
)
.WithCors(origins, headers, methods)
.OnAny(async ctx =>
{
var req = await ctx.GetRequestBodyAsStringAsync();
var headers = ctx.Request.Headers.ToStringDictionary().ToJson();
var query = ctx.GetRequestQueryData().ToStringDictionary().ToJson();
OnRequest?.Invoke(req, headers, query);
await ctx.SendDataAsync("OK");
});
return(server);
}
protected void ServerMethod()
{
internalPipe.WaitForConnection();
StreamHandler handler = new StreamHandler(new BufferedStream(internalPipe));
while (true)
{
string request = handler.ReadString();
string argument = handler.ReadString();
if (!internalPipe.IsConnected)
{
OnDisconnect?.Invoke(this, null);
}
OnRequest?.Invoke(request, argument, handler);
}
}
private async void BotOnMessageReceived(object sender, MessageEventArgs messageEventArgs)
{
/*
* по идее разных видов Response может быть много и каждый из них надо по особенному обрабатывать,
* думаю можно эту логику вынести в какой-нибудь responseHandler
*/
var message = messageEventArgs.Message;
try
{
var request = AnalyzeIncomingMessage(message);
OnRequest?.Invoke(request);
var response = Handler.ProcessMessage(request);
//TODO: проверка на null
if (response is ButtonResponse)
{
var buttonAnswer = (ButtonResponse)response;
await Bot.SendTextMessageAsync(message.Chat.Id, buttonAnswer.Text,
replyMarkup : GetKeyboard(buttonAnswer.ButtonNames));
}
else if (response is TextResponse)
{
var textAnswer = (TextResponse)response;
await Bot.SendTextMessageAsync(message.Chat.Id, textAnswer.Text);
}
else
{
await Bot.SendTextMessageAsync(message.Chat.Id, response.Text);
}
}
catch (ArgumentException e)
{
OnError?.Invoke(e);
await Bot.SendTextMessageAsync(message.Chat.Id, e.Message);
}
catch (Exception e)
{
OnError?.Invoke(e);
}
}
public async Task <ResponseData> RequestAsync(
string method,
string url,
IReadOnlyDictionary <string, string> headers,
string entityOpt = null
)
{
var args = new FakeClientRequestEventArgs(
RequestCounter += 1,
DefaultResponseData,
method,
url,
headers,
entityOpt
);
OnRequest?.Invoke(this, args);
await Task.Delay(0);
return(args.ResponseData);
}
private async void BotOnMessageReceived(object sender, MessageEventArgs messageEventArgs)
{
var message = messageEventArgs.Message;
try
{
var request = AnalyzeIncomingMessage(message);
OnRequest?.Invoke(request);
var response = ResponseHandler.ResponseAnalyzer(SessionHandler.ProcessMessage(request));
await Bot.SendTextMessageAsync(message.Chat.Id, response.Text, replyMarkup : response.Markup);
}
catch (ArgumentException e)
{
OnError?.Invoke(e);
await Bot.SendTextMessageAsync(message.Chat.Id, e.Message);
}
catch (Exception e)
{
OnError?.Invoke(e);
}
}
private void HandleMessage(Message message)
{
ThreadPool.QueueUserWorkItem(async delegate
{
if (message is RequestMessage requestMessage)
{
Message responseMessage = OnRequest?.Invoke(this, requestMessage.Request);
await SendAsync(new ResponseMessage(requestMessage.ID, responseMessage));
}
else if (message is ResponseMessage responseMessage)
{
if (pendingRequests.TryGetValue(responseMessage.RequestID, out TaskCompletionSource <Message> taskCompletionSource))
{
taskCompletionSource.TrySetResult(responseMessage.Response);
}
}
else
{
OnMessage?.Invoke(this, message);
}
});
private async void ListenAsyncImpl()
{
_listener.Start();
while (_listener.IsListening)
{
HttpListenerContext ctx = null;
try
{
ctx = await _listener.GetContextAsync().ConfigureAwait(false);
} catch (HttpListenerException e)
{
OnError?.Invoke(this, e);
}
if (ctx == null)
{
return;
}
OnRequest?.Invoke(this, ctx);
}
}
protected void WebsiteLife()
{
try
{
while (Listener.IsListening)
{
HttpListenerContext context = Listener.GetContext();
Task.Factory.StartNew(() =>
{
Stream output = context.Response.OutputStream;
byte[] buffer;
if (issipmle)
{
buffer = System.Text.Encoding.UTF8.GetBytes(onRequestSimple.Invoke(
context.Request.Url.AbsolutePath,
context.Request.Url.Query,
context.Request.HttpMethod
));
}
else
{
buffer = System.Text.Encoding.UTF8.GetBytes(onRequest.Invoke(context));
}
output.Write(buffer, 0, buffer.Length);
output.Close();
});
}
}
catch (ThreadAbortException ex)
{
//
}
catch (Exception ex)
{
throw new WebsiteException(ex);
}
}
static async void MakeAnalysisRequest(string filePath)
{
HttpClient client = new HttpClient();
client.DefaultRequestHeaders.Add("Ocp-Apim-Subscription-Key", subscriptionKey);
string requestParameters = "returnFaceId=true&returnFaceLandmarks=false" +
"&returnFaceAttributes=emotion";
string uri = uriBase + "?" + requestParameters;
HttpResponseMessage response;
var data = GetImageAsByteArray(filePath);
using (var content = new ByteArrayContent(data))
{
try
{
content.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
response = await client.PostAsync(uri, content);
var contentString = await response.Content.ReadAsStringAsync();
var json = JsonConvert.DeserializeObject <List <FaceResult> >(contentString);
OnRequest?.Invoke(json[0]);
Debug.Log(json[0]);
}
catch (Exception ex)
{
Debug.LogError(ex);
}
}
}
public Task Wait()
{
OnRequest?.Invoke(); return(_task.Task);
}
private async Task <bool> HandleClient(TcpClient client)
{
NetwrkWebClient webClient = new NetwrkWebClient(client);
if (Certificate != null)
{
await webClient.SslAuthenticateAsServerAsync(Certificate);
}
NetwrkWebRequest request = await webClient.ReceiveAsync <NetwrkWebRequest>();
if (request == null)
{
return(false);
}
if (request.IsWebSocketRequest)
{
if (OnWebsocketRequest?.Invoke(this, request) ?? true)
{
NetwrkWebResponse response = new NetwrkWebResponse
{
Version = request.Version,
StatusCode = NetwrkHttpStatusCode.SwitchingProtocols
};
response.Headers[NetwrkKnownHttpHeaders.Upgrade] = "websocket";
response.Headers[NetwrkKnownHttpHeaders.Connection] = "Upgrade";
response.Headers[NetwrkKnownHttpHeaders.Server] = "Netwrk/1.0";
using (var sha1 = SHA1.Create())
{
string accept = request.Headers[NetwrkKnownHttpHeaders.SecWebSocketKey] + NetwrkWebSocket.ConstantKey;
byte[] acceptBytes = Encoding.ASCII.GetBytes(accept);
byte[] acceptSha1 = sha1.ComputeHash(acceptBytes);
response.Headers[NetwrkKnownHttpHeaders.SecWebSocketAccept] = Convert.ToBase64String(acceptSha1);
}
await webClient.SendAsync(response);
NetwrkWebSocket webSocket = new NetwrkWebSocket(client, webClient.Stream);
OnWebSocketConnection?.Invoke(this, webSocket);
webSocket.Start();
}
}
else
{
NetwrkWebResponse response = OnRequest?.Invoke(this, request) ?? new NetwrkWebResponse
{
Version = request.Version,
StatusCode = NetwrkHttpStatusCode.InternalServerError
};
await webClient.SendAsync(response);
client.Close();
}
return(true);
}
private void ProcessReceivingMessages()
{
Task.Run(async() =>
{
while (socket.State == WebSocketState.Open)
{
ArraySegment <byte> buffer;
WebSocketReceiveResult result = null;
try
{
buffer = new ArraySegment <byte>(new byte[1024]);
result = await socket.ReceiveAsync(buffer, ReceiveTokenSource.Token);
}
catch (Exception ex)
{
socket = null;
IsActive = false;
IsConnected = false;
return;
}
if (result == null || result.Count == 0)
{
continue;
}
Kaenx.Konnect.Remote.MessageCodes code = (Konnect.Remote.MessageCodes)buffer.Array[0];
Debug.WriteLine("Got Remote Message: " + code);
//Check if assemby from this genügt
var q = from t in Assembly.LoadFrom("Kaenx.Konnect.dll").GetTypes()
where t.IsClass && t.IsNested == false && t.Namespace == "Kaenx.Konnect.Remote"
select t;
IRemoteMessage message = null;
foreach (Type t in q.ToList())
{
IRemoteMessage down = (IRemoteMessage)Activator.CreateInstance(t);
if (down != null && code == down.MessageCode)
{
message = down;
break;
}
}
if (message == null)
{
Debug.WriteLine("Unbekannte Nachricht: " + code);
}
try
{
message.Parse(buffer.Array.Take(result.Count).ToArray());
}
catch (Exception ex)
{
}
if (message is TunnelRequest && (message as TunnelRequest).Type == TunnelTypes.Connect)
{
TunnelRequest req = message as TunnelRequest;
KnxRemote rem = new KnxRemote(Encoding.UTF8.GetString(req.Data), this);
await rem.Init(getUsbHandler);
int connId = await rem.ConnectToInterface(req);
Remotes.Add(connId, rem);
continue;
}
if (message.ToString().EndsWith("Response"))
{
Responses[message.SequenceNumber] = message;
OnResponse?.Invoke(message);
}
else
{
OnRequest?.Invoke(message);
}
}
Debug.WriteLine("Verbindung abgebrochen");
});
}
protected void WebsiteLife()
{
try
{
while (Listener.IsListening)
{
HttpListenerContext context = Listener.GetContext();
Task.Factory.StartNew(() =>
{
Stream output = context.Response.OutputStream;
// GET Cookies
List <PanCookie> cookies = new List <PanCookie>();
foreach (Cookie c in context.Request.Cookies)
{
cookies.Add(new PanCookie(c.Name, c.Value, c.Path, c.Expires));
}
// GET Headers
Dictionary <string, string[]> headers = new Dictionary <string, string[]>();
System.Collections.Specialized.NameValueCollection cheaders = context.Request.Headers;
foreach (string key in cheaders.AllKeys)
{
string current_key = key;
string[] currentvalues = cheaders.GetValues(current_key);
}
// GET Data
string url = context.Request.RawUrl; // Url
string method = context.Request.HttpMethod; // Method
Stream inputStream = new MemoryStream(); // Body
bool hasEntityBody = context.Request.HasEntityBody; // Has Entity Body
if (hasEntityBody)
{
context.Request.InputStream.CopyTo(inputStream);
inputStream.Position = 0;
}
string[] acceptTypes = context.Request.AcceptTypes; // Accept Types
Encoding contentEncoding = context.Request.ContentEncoding; // Content Encoding
string contentType = context.Request.ContentType; // Content Type
bool isLocal = context.Request.IsLocal; // Is Local
string userAgent = context.Request.UserAgent; // User Agent
string[] userLanguages = context.Request.UserLanguages; // User Languages
IPEndPoint remoteEndPoint = context.Request.RemoteEndPoint; // User IP
string userIP = remoteEndPoint.Address.ToString();
PanRequest request = new PanRequest(method, url, inputStream, cookies, hasEntityBody, acceptTypes, contentEncoding, contentType, headers, isLocal, userAgent, userLanguages, userIP);
PanResponse response = onRequest.Invoke(request);
// SET Code
int code = response.Code;
context.Response.StatusCode = code;
// SET
context.Response.ContentType = response.MIME;
// SET Cookies
if (response.Cookies == null)
{
response.Cookies = new List <PanCookie>();
}
foreach (PanCookie c in response.Cookies)
{
string cookie = "";
cookie += (c.Name + "=" + (c.Value == null ? "" : c.Value));
if (c.Expires != null)
{
cookie += ("; Expires=" + c.Expires.ToString());
}
cookie += ("; Path=" + c.Path);
context.Response.Headers.Add("Set-Cookie", cookie);
}
response.OutputStream.CopyTo(output);
response.OutputStream.Close();
response.OutputStream.Dispose();
output.Close();
context.Response.Close();
});
}
}
catch (ThreadAbortException ex)
{
//
}
catch (Exception ex)
{
throw new WebsiteException(ex);
}
}
private void _channel_OnReceive(Transporter arg1, MemoryStream data)
{
short id;
if (!data.TryReadShort(out id))
{
HandleRequestProcessingError(
new ErrorMessage(
null, null,
ErrorType.SerializationError,
"Messae type id missed"), true);
return;
}
InputMessageDeserializeInfo sayDeserializer;
_inputSayMessageDeserializeInfos.TryGetValue(id, out sayDeserializer);
if (sayDeserializer == null)
{
HandleRequestProcessingError(
new ErrorMessage(id, data.TryReadShort(),
ErrorType.ContractSignatureError,
$"Message type id {id} is not implemented"), false);
return;
}
short?askId = null;
if (id < 0 || sayDeserializer.HasReturnType)
{
askId = data.TryReadShort();
if (!askId.HasValue)
{
HandleRequestProcessingError(
new ErrorMessage(
id, null,
ErrorType.SerializationError,
"Ask Id missed"), true);
return;
}
}
object[] deserialized;
try
{
deserialized = sayDeserializer.Deserialize(data);
}
catch (Exception ex)
{
if (id < 0)
{
//Answer deserialization failed. Send LocalSerializerException to upper layer as result of the ASK call
OnException?.Invoke(
this,
new LocalSerializationException(id, askId, "Answer deserialization failed: " + ex.Message, ex));
_channel.Disconnect();
return;
}
HandleRequestProcessingError(
new ErrorMessage(
id, askId,
ErrorType.SerializationError,
$"Message type id{id} with could not be deserialized. InnerException: {ex.ToString()}"), true);
return;
}
if (id < 0)
{
//input answer message handling
OnAns?.Invoke(this, id, askId.Value, deserialized.Single());
}
else if (id == Messenger.ExceptionMessageTypeId)
{
var exceptionMessage = (ErrorMessage)deserialized.First();
if (exceptionMessage.Exception.IsFatal)
{
_channel.DisconnectBecauseOf(exceptionMessage);
}
OnException?.Invoke(this, exceptionMessage.Exception);
}
else
{
//input ask / say messageHandling
OnRequest?.Invoke(this, new RequestMessage(id, askId, deserialized));
}
}
