using System;

using System.Collections.Generic;

using System.IO;

using System.IO.Compression;

using System.Linq;

using System.Net;

using System.Text;

using System.Text.RegularExpressions;

using System.Threading;

using System.Threading.Tasks;

using GrainInterface;

using Newtonsoft.Json;

using Orleans;

namespace PayServer

{

    public class HttpServer

    {

        private const string NotFoundResponse = "<!doctype html><html><body>Resource not found</body></html>";

        private readonly HttpListener httpListener;

        private readonly CancellationTokenSource cts = new CancellationTokenSource();

        private readonly string prefixPath;

        private Task processingTask;

        public HttpServer(string listenerUriPrefix)

        {

            this.prefixPath = ParsePrefixPath(listenerUriPrefix);

            this.httpListener = new HttpListener();

            this.httpListener.Prefixes.Add(listenerUriPrefix);

        }

        private static string ParsePrefixPath(string listenerUriPrefix)

        {

            var match = Regex.Match(listenerUriPrefix, @"http://(?:[^/]*)(?:\:\d+)?/(.*)");

            if (match.Success)

            {

                return match.Groups[].Value.ToLowerInvariant();

            }

            else

            {

                return string.Empty;

            }

        }

        public void Start()

        {

            this.httpListener.Start();

            this.processingTask = Task.Factory.StartNew(async () => await ProcessRequests(), TaskCreationOptions.LongRunning);

        }

        private async Task ProcessRequests()

        {

            while (!this.cts.IsCancellationRequested)

            {

                try

                {

                    var context = await this.httpListener.GetContextAsync();

                    try

                    {

                        await ProcessRequest(context).ConfigureAwait(false);

                        context.Response.Close();

                    }

                    catch (Exception ex)

                    {

                        context.Response.StatusCode = ;

                        context.Response.StatusDescription = "Internal Server Error";

                        context.Response.Close();

                        Console.WriteLine("Error processing HTTP request\n{0}", ex);

                    }

                }

                catch (ObjectDisposedException ex)

                {

                    if ((ex.ObjectName == this.httpListener.GetType().FullName) && (this.httpListener.IsListening == false))

                    {

                        return; // listener is closed/disposed

                    }

                    Console.WriteLine("Error processing HTTP request\n{0}", ex);

                }

                catch (Exception ex)

                {

                    HttpListenerException httpException = ex as HttpListenerException;

                    if (httpException == null || httpException.ErrorCode != )// IO operation aborted

                    {

                        Console.WriteLine("Error processing HTTP request\n{0}", ex);

                    }

                }

            }

        }

        private Task ProcessRequest(HttpListenerContext context)

        {

            if (context.Request.HttpMethod.ToUpperInvariant() != "GET")

            {

                return WriteNotFound(context);

            }

            var urlPath = context.Request.RawUrl.Substring(this.prefixPath.Length)

                .ToLowerInvariant();

            switch (urlPath)

            {

                case "/":

                    if (!context.Request.Url.ToString().EndsWith("/"))

                    {

                        context.Response.Redirect(context.Request.Url + "/");

                        context.Response.Close();

                        return Task.FromResult();

                    }

                    else

                    {

                        return WriteString(context, "Hello World!", "text/plain");

                    }

                case "/favicon.ico":

                    return WriteFavIcon(context);

                case "/ping":

                    return WritePong(context);

                case "/pay":

                    return OnPayResult(context);

            }

            return WriteNotFound(context);

        }

        private static Task WritePong(HttpListenerContext context)

        {

            return WriteString(context, "pong", "text/plain");

        }

        private static async Task OnPayResult(HttpListenerContext context)

        {

            var ret = "failed";

            try

            {

                string postData;

                using (var br = new BinaryReader(context.Request.InputStream))

                {

                    postData =

                        Encoding.UTF8.GetString(

                            br.ReadBytes(int.Parse(context.Request.ContentLength64.ToString())));

                }

                if (!string.IsNullOrEmpty(postData))

                {

                    Console.WriteLine("postData=[{0}]", postData);

                    var request = JsonConvert.DeserializeObject<PayResult>(postData);

                    if (null != request)

                    {

                        var parmas = request.data.orderNo.Split(',');

                        var id = long.Parse(parmas[]);

                        var playerProxy = GrainClient.GrainFactory.GetGrain<IPlayerProxy>(id);

                        var success =

                            await playerProxy.OnPlayerPayResult(request.data.orderNo, request.code, request.msg);

                        if (success)

                        {

                            ret = "success";

                        }

                    }

                }

            }

            catch (Exception e)

            {

                Console.WriteLine(e);

            }

            await WriteString(context, ret, "text/plain");

        }

        private static async Task WriteFavIcon(HttpListenerContext context)

        {

            context.Response.ContentType = "image/png";

            context.Response.StatusCode = ;

            context.Response.StatusDescription = "OK";

            using (var stream = File.Open("icon.png", FileMode.Open))

            {

                var output = context.Response.OutputStream;

                await stream.CopyToAsync(output);

            }

        }

        private static Task WriteNotFound(HttpListenerContext context)

        {

            return WriteString(context, NotFoundResponse, "text/plain", , "NOT FOUND");

        }

        private static async Task WriteString(HttpListenerContext context, string data, string contentType,

            int httpStatus = , string httpStatusDescription = "OK")

        {

            AddCORSHeaders(context.Response);

            AddNoCacheHeaders(context.Response);

            context.Response.ContentType = contentType;

            context.Response.StatusCode = httpStatus;

            context.Response.StatusDescription = httpStatusDescription;

            var acceptsGzip = AcceptsGzip(context.Request);

            if (!acceptsGzip)

            {

                using (var writer = new StreamWriter(context.Response.OutputStream, Encoding.UTF8, , true))

                {

                    await writer.WriteAsync(data).ConfigureAwait(false);

                }

            }

            else

            {

                context.Response.AddHeader("Content-Encoding", "gzip");

                using (GZipStream gzip = new GZipStream(context.Response.OutputStream, CompressionMode.Compress, true))

                using (var writer = new StreamWriter(gzip, Encoding.UTF8, , true))

                {

                    await writer.WriteAsync(data).ConfigureAwait(false);

                }

            }

        }

        private static bool AcceptsGzip(HttpListenerRequest request)

        {

            string encoding = request.Headers["Accept-Encoding"];

            if (string.IsNullOrEmpty(encoding))

            {

                return false;

            }

            return encoding.Contains("gzip");

        }

        private static void AddNoCacheHeaders(HttpListenerResponse response)

        {

            response.Headers.Add("Cache-Control", "no-cache, no-store, must-revalidate");

            response.Headers.Add("Pragma", "no-cache");

            response.Headers.Add("Expires", "");

        }

        private static void AddCORSHeaders(HttpListenerResponse response)

        {

            response.Headers.Add("Access-Control-Allow-Origin", "*");

            response.Headers.Add("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept");

        }

        private void Stop()

        {

            cts.Cancel();

            if (processingTask != null && !processingTask.IsCompleted)

            {

                processingTask.Wait();

            }

            if (this.httpListener.IsListening)

            {

                this.httpListener.Stop();

                this.httpListener.Prefixes.Clear();

            }

        }

        public void Dispose()

        {

            this.Stop();

            this.httpListener.Close();

            using (this.cts) { }

            using (this.httpListener) { }

        }

    }

}

C# HTTPServer和OrleansClient结合的更多相关文章

  1. NodeJS 最快速搭建一个HttpServer

    最快速搭建一个HttpServer 在目录里放一个index.html cd D:\Web\InternalWeb start http-server -i -p 8081

  2. 基于Netty4的HttpServer和HttpClient的简单实现

    Netty的主页:http://netty.io/index.html 使用的Netty的版本:netty-4.0.23.Final.tar.bz2 ‐ 15-Aug-2014 (Stable, Re ...

  3. libevent源码分析：http-server例子

    http-server例子是libevent提供的一个简单web服务器,实现了对静态网页的处理功能. /* * gcc -g -o http-server http-server.c -levent ...

  4. httpserver

    改了下 # -*- coding:utf-8 -*- from BaseHTTPServer import HTTPServer, BaseHTTPRequestHandler HOST = &quo ...

  5. 一个简单的零配置命令行HTTP服务器 - http-server (nodeJs)

    http-server 是一个简单的零配置命令行HTTP服务器, 基于 nodeJs. 如果你不想重复的写 nodeJs 的 web-server.js, 则可以使用这个. 安装 (全局安装加 -g) ...

  6. nodejs搭建http-server

      很多时候我们都需要搭建一个简单的服务器,部署在IIS,阿帕奇,或者用nodejs,网上很多关于nodejs搭建server的文章,但都是要创建server.js,很麻烦, 在这里我分享一个创建ht ...

  7. 一、HTTPServer，RequestHandler，ServerHandler，Handler

    1.      HTTPServer,RequestHandler,ServerHandler,Handler 1.1       基本概念 HTTPServer主要是对传输控制层HTTP,TCP,S ...

  8. nodejs：本地文件夹http服务器http-server

    一.已经安装nodejs的电脑,有一个方便通过http访问本地文件夹.文件夹服务器 static files over HTTP,并不是我们平常说的node那个web服务器哦 二.好处 可以方便实现跨 ...

  9. PHP使用libevent实现高性能httpServer

    今天发现php也有一个libevent的扩展,安装后尝试下了一个webserver(httpserver), 发现性能还不错,逻辑很简单,每秒响应速度1800~4000次/s 代码如下 <?ph ...

随机推荐

  1. Unity Shader-后处理：Bloom全屏泛光

    一.简介   今天来学习一下全屏Bloom效果,有时候也叫Glow效果,中文一般叫做“全屏泛光”,这是一种可以模拟出HDR的全屏后处理效果,但是实现原理与HDR相差很远,效果比HDR差一些,但是比HD ...

  2. request.getParameter(“xxx”)的参数的取值

    request.getParameter(“xxx”)的参数的取值的几种可能: 1. Html中form表单中标签的name属性: <form name="form" met ...

  3. Zookeeper单机伪集群

    Zookeeper单机伪集群 1.配置 zookeeper下载地址:http://apache.mirrors.lucidnetworks.net/zookeeper/ 可以选择需要的版本,我下载的是 ...

  4. android: 在android studio中使用retrolambda的步骤

    找了各种说明,包括retrolambda官方文档都没有试成功 最后在这个链接中找到答案:http://blog.csdn.net/qq_26819733/article/details/5222565 ...

  5. 五花八门的Shell 的相关概念和配置方法

    使用Linux的过程中少不了使用各种各样的Shell, 而根据启动环境的不同,Shell会读取不同的配置文件. 本文便来详细介绍这些不同名字的配置文件在何时会被Shell读取. 什么是 Shell S ...

  6. Mac Apache WebDav 服务器配置

    1.WebDav 服务器 基于 http 协议的 "文件" 服务器. 实现文件的上传/下载/修改/删除. WebDav 权限 授权信息的格式 BASIC (用户名:口令)base6 ...

  7. React Native 设置RGBA背景色

    React Native 设置RGBA背景色: 可以先用Mac自带吸色工具,获取RGB值,然后设置背景如下: backgroundColor: 'rgba(52, 52, 52, 0.8)', 透明度 ...

  8. FFmpeg: AVPacket 结构体分析

    AVPacket是FFmpeg中很重要的一个数据结构,它保存了解封装之后,解码之前的数据(注意:仍然是压缩后的数据)和关于这些数据的一些附加信息,如显示时间戳(pts).解码时间戳(dts).数据时长 ...

  9. github贡献开源项目

    1.正常流程 1.拷贝项目到自己的github 2.本地修改后提交远程仓库 3.创建讨论Pull requests 4.开源项目者合并到master分支 5.删除仓库 2.快速发出讨论Pull req ...

  10. Android查询不到电话号码解决方法

    貌似联系人有三个数据库,且不同步,另外也有可能是版本问题. 解决方案:https://github.com/codinguser/android_contact_picker 接下来会对其进行一些改造 ...