FilesExpand file tree

 develop

/

WebServer.cs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

236 lines (196 loc) · 8.15 KB

 develop

/

WebServer.cs

Copy path

Top

File metadata and controls

• Code
• Blame

236 lines (196 loc) · 8.15 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

89

90

91

92

93

94

95

96

97

98

99

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

/*----------------------------------------------------------

This Source Code Form is subject to the terms of the

Mozilla Public License, v.2.0. If a copy of the MPL

was not distributed with this file, You can obtain one

at http://mozilla.org/MPL/2.0/.

----------------------------------------------------------*/

using Microsoft.AspNetCore.Builder;

using Microsoft.AspNetCore.Hosting;

using Microsoft.AspNetCore.Http;

using Microsoft.AspNetCore.Http.Features;

using OneScript.Contexts;

using OneScript.Types;

using ScriptEngine.Machine;

using ScriptEngine.Machine.Contexts;

using System;

using System.Collections.Generic;

using System.Threading.Tasks;

using Microsoft.AspNetCore.Diagnostics;

using Microsoft.Extensions.Configuration;

using Microsoft.Extensions.DependencyInjection;

using OneScript.Execution;

namespace OneScript.Web.Server

{

[ContextClass("ВебСервер", "WebServer")]

public class WebServer: AutoContext<WebServer>

{

private readonly ExecutionContext _executionContext;

private WebApplication _app;

private readonly List<(IRuntimeContextInstance Target, string MethodName)> _middlewares = new List<(IRuntimeContextInstance Target, string MethodName)>();

private string _contentRoot = null;

private string _wwwRoot;

private bool _useStaticFiles = false;

private bool _useWebSockets = false;

private (IRuntimeContextInstance Target, string MethodName)? _exceptionHandler = null;

[ContextProperty("Порт", "Port", CanWrite = false)]

public int Port { get; private set; }

public WebServer(ExecutionContext executionContext)

{

_executionContext = executionContext;

}

[ScriptConstructor(Name = "С портом по умолчанию - 8080")]

public static WebServer Constructor(TypeActivationContext typeActivationContext)

{

var server = new WebServer(typeActivationContext.Services.Resolve<ExecutionContext>())

{

Port = 8080

};

return server;

}

[ScriptConstructor(Name = "С указанием порта прослушивателя")]

public static WebServer Constructor(TypeActivationContext typeActivationContext, IValue port)

{

var server = new WebServer(typeActivationContext.Services.Resolve<ExecutionContext>())

{

Port = (int)port.AsNumber()

};

return server;

}

[ContextMethod("Запустить", "Run")]

public void Run()

{

ConfigureApp();

_app.Run();

}

/// <summary>

/// Останавливает веб-сервер

/// </summary>

[ContextMethod("Остановить", "Stop")]

public void Stop()

{

_app?.StopAsync().Wait();

}

private void ConfigureApp()

{

var appOptions = new WebApplicationOptions

{

ContentRootPath = _contentRoot,

WebRootPath = _wwwRoot

};

var builder = WebApplication.CreateBuilder(appOptions);

builder.WebHost.ConfigureKestrel(options =>

{

var kestrelSection = builder.Configuration.GetSection("Kestrel");

options.Configure(kestrelSection);

kestrelSection.Bind(options);

options.AllowSynchronousIO = true;

options.ListenAnyIP(Port);

});

builder.Services.Configure<FormOptions>(builder.Configuration.GetSection("FormOptions"));

_app = builder.Build();

if (_useStaticFiles)

_app.UseStaticFiles();

if (_exceptionHandler != null)

{

UseBslExceptionHandler();

}

else

{

UseDefaultExceptionHandler();

}

if (_useWebSockets)

_app.UseWebSockets();

_app.Use((context, next) =>

{

var process = _executionContext.Services.Resolve<IBslProcessFactory>().NewProcess();

context.Items.Add(typeof(IBslProcess), process);

return next();

});

_middlewares.ForEach(middleware =>

{

_app.Use((context, next) =>

{

var args = new IValue[]

{

new HttpContextWrapper(_executionContext.TypeManager, context),

new RequestDelegateWrapper(next)

};

var process = (IBslProcess)context.Items[typeof(IBslProcess)];

var methodNumber = middleware.Target.GetMethodNumber(middleware.MethodName);

middleware.Target.CallAsProcedure(methodNumber, args, process);

return Task.CompletedTask;

});

});

}

private void UseDefaultExceptionHandler()

{

_app.UseExceptionHandler(errApp =>

{

errApp.Run(context =>

{

var exceptionHandlerPathFeature =

context.Features.Get<IExceptionHandlerPathFeature>();

WriteExceptionToResponse(context, exceptionHandlerPathFeature?.Error);

return Task.CompletedTask;

});

});

}

private void UseBslExceptionHandler()

{

_app.UseExceptionHandler(handler =>

{

handler.Run(context =>

{

var args = new IValue[]

{

new HttpContextWrapper(_executionContext.TypeManager, context),

};

var methodNumber = _exceptionHandler?.Target.GetMethodNumber(_exceptionHandler?.MethodName)

?? throw new InvalidOperationException();

var process = _executionContext.Services.Resolve<IBslProcessFactory>().NewProcess();

try

{

_exceptionHandler?.Target.CallAsProcedure(methodNumber, args, process);

}

catch (Exception ex)

{

if (!context.Response.HasStarted)

WriteExceptionToResponse(context, ex);

else

throw;

}

return Task.CompletedTask;

});

});

}

private static void WriteExceptionToResponse(HttpContext httpContext, Exception ex)

{

httpContext.Response.StatusCode = 500;

httpContext.Response.ContentType = "text/plain;charset=utf-8";

httpContext.Response.WriteAsync(ex.Message).Wait();

}

[ContextMethod("ДобавитьОбработчикЗапросов", "AddRequestsHandler")]

public void SetRequestsHandler(IRuntimeContextInstance target, string methodName)

=> _middlewares.Add((target, methodName));

[ContextMethod("ИспользоватьВебСокеты", "UseWebSockets")]

public void UseWebSockets() => _useWebSockets = true;

[ContextMethod("ДобавитьОбработчикИсключений", "AddExceptionsHandler")]

public void SetExceptionsHandler(IRuntimeContextInstance target, string methodName)

=> _exceptionHandler = (target, methodName);

[ContextMethod("УстановитьКаталогСервера", "SetServerDir")]

public void SetContentRoot(string path)

{

_contentRoot = path;

}

[ContextMethod("УстановитьКорневойПуть", "SetWebRoot")]

public void SetWebRoot(string path)

{

_wwwRoot = path;

}

[ContextMethod("ИспользоватьСтатическиеФайлы", "UseStaticFiles")]

public void UseStaticFiles()

{

_useStaticFiles = true;

}

}

}