public static void Main(string[] args)
{
var container = new Container();
container.Configure(config => {
config.Scan(_ => {
_.AssembliesFromApplicationBaseDirectory();
_.RegisterConcreteTypesAgainstTheFirstInterface();
_.WithDefaultConventions();
});
});
var services = new ServiceCollection();
var serviceProvider = services.BuildServiceProvider();
var options = new NodeServicesOptions(serviceProvider);
var assembly = typeof(Program).GetTypeInfo().Assembly;
var directory = Path.GetDirectoryName(assembly.Location).Replace("/bin/Debug/netcoreapp1.1", string.Empty);
options.ProjectPath = directory;
var nodeServices = NodeServicesFactory.CreateNodeServices(options);
System.Console.WriteLine("Invoking");
nodeServices.InvokeExportAsync <int>("./test", "addNumbers", 1, 2).ContinueWith(r => {
System.Console.WriteLine($"Result is {r.Result}");
});
//var orchestrator = container.GetInstance<DeploymentOrchestrator>();
System.Console.WriteLine("Press any key");
System.Console.ReadLine();
}
/// <summary>
/// Adds HTTPS support for <c>NodeServices</c>.
/// </summary>
/// <param name="options"><c>NodeServices</c> options.</param>
/// <param name="configuration">Application configuration.</param>
/// <returns></returns>
/// <exception cref="ArgumentNullException"></exception>
public static NodeServicesOptions AddHttps(
this NodeServicesOptions options,
IConfiguration configuration
)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
options.EnvironmentVariables.Add("HttpsToHttpUrlTransform", "true");
var serverUrls = GetServerUrls(configuration);
var serverHttpsUrlsJson = JsonSerializer.Serialize(serverUrls.HttpsUrls);
var serverHttpUrlsJson = JsonSerializer.Serialize(serverUrls.HttpUrls);
options.EnvironmentVariables.Add("ServerHttpsUrls", serverHttpsUrlsJson);
options.EnvironmentVariables.Add("ServerHttpUrls", serverHttpUrlsJson);
return(options);
}
public async Task BuiltInModuleResolved()
{
var stopTokenSource = new CancellationTokenSource();
var options = new NodeServicesOptions
{
ApplicationStoppingToken = stopTokenSource.Token,
ProjectPath = AppDomain.CurrentDomain.BaseDirectory,
NodeInstanceOutputLogger = Mock.Of <ILogger>(),
};
options.UseSocketHosting();
using (var services = NodeServicesFactory.CreateNodeServices(options))
using (var builtinModule = new StringAsTempFile("exports.add = function(a, b) {return a+b;}", stopTokenSource.Token))
{
await services.InvokeExportAsync <object>("builtin-modules-init", "initialize",
new Dictionary <string, string>()
{
{ "builtin", builtinModule.FileName }
});
var result = await services.InvokeExportAsync <int>("builtin-modules-test", "test", 1, 2);
stopTokenSource.Cancel();
Assert.Equal(3, result);
}
}
private async Task CreateNodeInstances(NodeServicesOptions options)
{
for (int i = 0; i < _services.Length; ++i)
{
_services[i] = new HotNodeService(CreateNodeInstance(options));
await WarmupService(_services[i], CancellationToken.None);
}
}
private static NodeServicesOptions DefaultNodeServicesOptions()
{
var options = new NodeServicesOptions(new ServiceCollection().BuildServiceProvider())
{
ProjectPath = Directory.GetCurrentDirectory()
};
return(options);
}
public NodeServicesEngine()
{
var options = new NodeServicesOptions(new EmptyServiceProvider())
{
EnvironmentVariables = { ["NODE_ENV"] = "production" }
};
_nodeServices = NodeServicesFactory.CreateNodeServices(options);
}
/// <summary>
/// Create an <see cref="INodeServices" /> instance according to the supplied options.
/// </summary>
/// <param name="options">Options for creating the <see cref="INodeServices" /> instance.</param>
/// <returns>An <see cref="INodeServices" /> instance.</returns>
public static INodeServices CreateNodeServices(NodeServicesOptions options)
{
if (options == null)
{
throw new ArgumentNullException(nameof(options));
}
return(new NodeServicesImpl(options.NodeInstanceFactory));
}
public HandlerFactoryFixture()
{
var options = new NodeServicesOptions(new ServiceCollection().BuildServiceProvider())
{
ProjectPath = Directory.GetCurrentDirectory()
};
var nodeServices = NodeServicesFactory.CreateNodeServices(options);
Factory = new HandlerFactory(nodeServices, typeof(string).GetTypeInfo().Assembly); // mscorlib
}
public NodeServicesPool(int serviceCount, IServiceProvider sp)
{
_serviceBag = new ConcurrentBag <INodeServices>();
var options = new NodeServicesOptions(sp);
for (int i = 0; i < serviceCount; i++)
{
_serviceBag.Add(NodeServicesFactory.CreateNodeServices(options));
}
_semaphore = new SemaphoreSlim(serviceCount);
}
public static void AddDebugNodeServices(this IServiceCollection services, int startPort = 9229)
{
var port = startPort;
services.AddTransient <INodeServices>(serviceProvider => {
var options = new NodeServicesOptions(serviceProvider);
options.LaunchWithDebugging = true;
options.DebuggingPort = port;
port++;
return(NodeServicesFactory.CreateNodeServices(options));
});
}
public Visualizer(string baseDir)
{
_baseDir = baseDir;
var services = new ServiceCollection();
services.AddNodeServices();
var options = new NodeServicesOptions(services.BuildServiceProvider())
{
ProjectPath = Directory.GetCurrentDirectory()
};
_node = NodeServicesFactory.CreateNodeServices(options);
}
private static INodeServices CreateNodeServicesInstance(
IApplicationBuilder appBuilder, string sourcePath)
{
// Unlike other consumers of NodeServices, AngularCliMiddleware dosen't share Node instances, nor does it
// use your DI configuration. It's important for AngularCliMiddleware to have its own private Node instance
// because it must *not* restart when files change (it's designed to watch for changes and rebuild).
var nodeServicesOptions = new NodeServicesOptions(appBuilder.ApplicationServices)
{
WatchFileExtensions = new string[] { }, // Don't watch anything
ProjectPath = Path.Combine(Directory.GetCurrentDirectory(), sourcePath),
};
return(NodeServicesFactory.CreateNodeServices(nodeServicesOptions));
}
public HandlerFactoryFixture()
{
var resolvers = new List <IMetadataReferenceResolver> {
new DefaultMetadataReferenceResolver()
};
var builder = new DefaultAssemblyBuilder(new DefaultAssemblyLoadContextProvider(), resolvers);
var options = new NodeServicesOptions(new ServiceCollection().BuildServiceProvider())
{
ProjectPath = Directory.GetCurrentDirectory()
};
var nodeServices = NodeServicesFactory.CreateNodeServices(options);
Factory = new HandlerFactory(builder, nodeServices, typeof(string).GetTypeInfo().Assembly); // mscorlib
}
public HttpNodeInstance(NodeServicesOptions options, int port = 0)
: base(
EmbeddedResourceReader.Read(typeof(OutOfProcessNodeInstance), "/Content/Node/entrypoint-http.js"),
options.ProjectPath,
options.WatchFileExtensions,
MakeCommandLineOptions(port),
options.ApplicationStoppingToken,
options.NodeInstanceOutputLogger,
options.EnvironmentVariables,
options.InvocationTimeoutMilliseconds,
options.LaunchWithDebugging,
options.DebuggingPort)
{
_client = new HttpClient();
_client.Timeout = TimeSpan.FromMilliseconds(options.InvocationTimeoutMilliseconds + 1000);
}
public static void Validate(string typescriptSource)
{
if (s_nodeServices == null)
{
var options = new NodeServicesOptions(NullServiceProvider.Instance);
s_nodeServices = NodeServicesFactory.CreateNodeServices(options);
}
var task = s_nodeServices.InvokeAsync <string>("TypeScriptValidator.js", typescriptSource);
var result = task.GetAwaiter().GetResult();
if (result != "success")
{
Assert.Fail("\n" + typescriptSource + "\n\nErrors:\n" + result);
}
}
public SocketNodeInstance(NodeServicesOptions options, string socketAddress)
: base(
EmbeddedResourceReader.Read(
typeof(SocketNodeInstance),
"/Content/Node/entrypoint-socket.js"),
options.ProjectPath,
options.WatchFileExtensions,
MakeNewCommandLineOptions(socketAddress),
options.ApplicationStoppingToken,
options.NodeInstanceOutputLogger,
options.EnvironmentVariables,
options.InvocationTimeoutMilliseconds,
options.LaunchWithDebugging,
options.DebuggingPort)
{
_socketAddress = socketAddress;
}
/// <summary>
/// Adds NodeServices support to the <paramref name="serviceCollection"/>.
/// </summary>
/// <param name="serviceCollection">The <see cref="IServiceCollection"/>.</param>
/// <param name="setupAction">A callback that will be invoked to populate the <see cref="NodeServicesOptions"/>.</param>
public static void AddNodeServices(this IServiceCollection serviceCollection, Action <NodeServicesOptions> setupAction)
{
if (setupAction == null)
{
throw new ArgumentNullException(nameof(setupAction));
}
serviceCollection.AddSingleton(typeof(INodeServices), serviceProvider =>
{
// First we let NodeServicesOptions take its defaults from the IServiceProvider,
// then we let the developer override those options
var options = new NodeServicesOptions(serviceProvider);
setupAction(options);
return(NodeServicesFactory.CreateNodeServices(options));
});
}
/// <summary>
/// Initializes a new instance of the <see cref="NodeRenderEngine" /> class.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="options">The options.</param>
public NodeRenderEngine(IServiceProvider serviceProvider, NodeRenderEngineOptions options)
{
_options = options;
var nodeOptions = new NodeServicesOptions(serviceProvider)
{
HostingModel = options.NodeHostingModel,
ProjectPath = options.ProjectDirectory,
WatchFileExtensions = options.WatchFileExtensions
};
if (options.NodeInstanceOutputLogger != null)
{
nodeOptions.NodeInstanceOutputLogger = options.NodeInstanceOutputLogger;
}
_nodeServices = NodeServicesFactory.CreateNodeServices(nodeOptions);
}
public static IApplicationBuilder UseParcelBundler(this IApplicationBuilder app, ParcelBundlerOptions options)
{
var environment = app.ApplicationServices.GetService <IHostingEnvironment>();
var nodeServiceOptions = new NodeServicesOptions(app.ApplicationServices)
{
WatchFileExtensions = new string[] { }
};
string content = LoadScriptContent();
var script = new StringAsTempFile(content, nodeServiceOptions.ApplicationStoppingToken);
var node = NodeServicesFactory.CreateNodeServices(nodeServiceOptions);
var args = new
{
entryPoints = options.EntryPoints,
options = new
{
outDir = Path.Combine(environment.WebRootPath, options.OutDir ?? ""),
outFile = options.OutFile,
publicUrl = options.PublicUrl,
watch = options.Watch,
cache = options.Cache,
cacheDir = options.CacheDir,
contentHash = options.ContentHash,
minify = options.Minify,
scopeHoist = options.ScopeHoist,
target = options.Target?.ToString().ToLower(),
https = options.Https?.ToParcelOptions(),
hmr = options.HotModuleReload?.IsEnabled,
hmrPort = options.HotModuleReload?.Port,
sourcemaps = options.SourceMaps,
hmrHostname = options.HotModuleReload?.Hostname,
detailedReport = options.DetailedReport
}
};
var response = node.InvokeExportAsync <ParcelServerInfo>(script.FileName, "runParcelBundler", JsonConvert.SerializeObject(args, SerializerSettings))
.Result;
return(app);
}
public PugRenderingTestsFixture()
{
var optionsMock = new Mock <IOptions <PugzorViewEngineOptions> >();
optionsMock.SetupGet(q => q.Value)
.Returns(new PugzorViewEngineOptions
{
// true: makes a lot of tests to fail
Pretty = false
});
var mockServices = new Mock <IServiceProvider>();
var nodeServiceOptions = new NodeServicesOptions(mockServices.Object)
{
ProjectPath = TemporaryDirectoryHelper.CreateTemporaryDirectory(true)
};
var nodeServices = NodeServicesFactory.CreateNodeServices(nodeServiceOptions);
Renderer = new PugRendering(nodeServices, optionsMock.Object);
}
public NodeBindingTests()
{
var options = new NodeServicesOptions
{
ApplicationStoppingToken = stopTokenSource.Token,
ProjectPath = AppDomain.CurrentDomain.BaseDirectory,
NodeInstanceOutputLogger = Mock.Of <ILogger>(),
DebuggingPort = 9000,
LaunchWithDebugging = true
};
options.UseSocketHosting();
nodeServices = NodeServicesFactory.CreateNodeServices(options);
rpcHost = new JsonRpcBindingHost(js => new LineDelimitedJsonConnection(js));
rpcHost.Repository.AddBinding("test", new TestBound());
var initTask = nodeServices.InvokeExportAsync <Stream>("binding-init", "initialize", rpcHost.Repository.Objects);
this.initTask = initTask.ContinueWith(t => (rpcHost.Connection as LineDelimitedJsonConnection)?.Initialize(t.Result, t.Result));
}
public static async Task <TResult> RunAsync <TData, TResult>(string module, TData data)
{
var services = new ServiceCollection();
services.AddNodeServices(a =>
{
// a.ProjectPath = Directory.GetCurrentDirectory();
// Set any properties that you want on 'options' here
});
var serviceProvider = services.BuildServiceProvider();
var options = new NodeServicesOptions(serviceProvider)
{
ProjectPath = Directory.GetCurrentDirectory() + "/tmphost",
InvocationTimeoutMilliseconds = 60000 * 5,
};
var nodeServices = NodeServicesFactory.CreateNodeServices(options);
var sb = new StringBuilder();
// sb.AppendLine("return function (data,callback){");
sb.AppendLine("var requirejs = require(\"requirejs\");");
sb.AppendLine($"var r = requirejs.config({{ baseUrl:'{Path.Combine(Directory.GetCurrentDirectory(), "artifacts/app").Replace("\\", "/")}'}});");
sb.AppendLine("module.exports= function (callback,data){ try{");
sb.AppendLine($"r([\"{module}\"], function (program) {{ program.default(data, callback); }},function(err){{ console.log('host failed'); callback(err,null) }})");
sb.AppendLine("}catch(error){console.log('host catch');callback(error,null); }}");
Directory.CreateDirectory("tmphost");
File.WriteAllText("tmphost/run.js", sb.ToString());
return(await nodeServices.InvokeAsync <TResult>("./run", data));
// return JToken.FromObject(await Edge.Func(sb.ToString())(data)).ToObject<TResult>();
}
/// <summary>
/// Initializes a new instance of the <see cref="NodeRenderEngine" /> class.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="options">The options.</param>
public NodeRenderEngine(IServiceProvider serviceProvider, NodeRenderEngineOptions options)
{
_options = options;
var nodeOptions = new NodeServicesOptions(serviceProvider ?? new EmptyServiceProvider())
{
ProjectPath = options.ProjectDirectory,
WatchFileExtensions = options.WatchFileExtensions,
EnvironmentVariables = options.EnvironmentVariables,
DebuggingPort = options.DebuggingPort,
LaunchWithDebugging = options.LaunchWithDebugging
};
if (options.NodeInstanceFactory != null)
{
nodeOptions.NodeInstanceFactory = options.NodeInstanceFactory;
}
if (options.NodeInstanceOutputLogger != null)
{
nodeOptions.NodeInstanceOutputLogger = options.NodeInstanceOutputLogger;
}
_nodeServices = NodeServicesFactory.CreateNodeServices(nodeOptions);
}
private async Task <int> OnExecuteAsync(CommandLineApplication app)
{
if (string.IsNullOrEmpty(Url) && string.IsNullOrEmpty(RemotePageLocation) && !HelloWorld)
{
app.ShowHelp();
return(0);
}
Console.WriteLine(HostFolder);
Directory.CreateDirectory(HostFolder);
Directory.CreateDirectory("output");
await InstallNPMPackage(HostFolder, "requirejs");
await InstallNPMPackage(HostFolder, "puppeteer");
await InstallNPMPackage(HostFolder, "websocket");
await InstallNPMPackage(HostFolder, "isomorphic-fetch");
await InstallNPMPackage(HostFolder, "earthml-temply-headless");
var engine = new RazorLightEngineBuilder()
.UseEmbeddedResourcesProject(typeof(Program))
.UseMemoryCachingProvider()
.Build();
Console.WriteLine(string.Join(" ", app.RemainingArguments));
var args = new JObject();
for (var j = 0; j < app.RemainingArguments.Count; j += 2)
{
args[app.RemainingArguments[j].Trim('-')] = app.RemainingArguments[j + 1];
}
IWebHost host = new WebHostBuilder()
.UseKestrel()
.Configure(appbuilder =>
{
appbuilder.Use(async(context, next) =>
{
Console.WriteLine(context.Request.Path);
if (context.Request.Path == "/installDependencies")
{
var dps = JToken.Parse(await new StreamReader(context.Request.Body).ReadToEndAsync());
foreach (JProperty dependency in dps.SelectToken("$.dependencies"))
{
await InstallNPMPackage(HostFolder, dependency.Name, dependency.Value.ToString());
}
context.Response.StatusCode = 200;
return;
}
if (context.Request.Path == "/hello-world")
{
await context.Response.WriteAsync(@"<html><head><script src=""node_modules/requirejs/require.js""></script></head><body><script type=""text/javascript"">require.config({paths:{'earthml-temply-headless':'node_modules/earthml-temply-headless/artifacts/src'}}); require(['earthml-temply-headless/remotepage/remotepage'],(RemotePageModule)=>{console.log(RemotePageModule);let rp = new RemotePageModule.RemotePage(); rp.helloWorld(); })</script></body></html>");
return;
}
if (context.Request.Path == "/")
{
try
{
string result = await engine.CompileRenderAsync("GenericRemoteHost.cshtml", new { Name = "John Doe" });
await context.Response.WriteAsync(result);
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
return;
}
await next();
Console.WriteLine($"{context.Request.Path} {context.Response.StatusCode}");
});
foreach (var volumne in Volumes)
{
appbuilder.Map(volumne.Split(':').Last(), (b) =>
{
b.Use(async(ctx, next) =>
{
await next();
Console.WriteLine($"{ctx.Request.Path} {ctx.Response.StatusCode}");
});
b.UseStaticFiles(new StaticFileOptions {
FileProvider = new PhysicalFileProvider(string.Join(":", volumne.Split(':').Reverse().Skip(1).Reverse()))
});
});
}
//appbuilder.Map("/appinsight", (b) =>
//{
// b.UseStaticFiles(new StaticFileOptions { FileProvider = new Microsoft.Extensions.FileProviders.PhysicalFileProvider(@"C:\dev\EarthML\EarthML.TemplyHeadless\samples\ApplicationInsightsGraphGenerator\wwwroot") });
//});
//appbuilder.Map("/AscendRegistration", (b) =>
//{
// b.UseStaticFiles(new StaticFileOptions { FileProvider = new Microsoft.Extensions.FileProviders.PhysicalFileProvider(@"C:\dev\Ascend\AscendRecording\AscendRecording\www\libs\AscendRegistration") });
//});
//appbuilder.Map("/node_modules/earthml-temply-headless/artifacts/src", (b) =>
//{
// b.UseStaticFiles(new StaticFileOptions { FileProvider = new PhysicalFileProvider("C:/dev/EarthML/EarthML.TemplyHeadless/src/EarthML.TemplyHeadless/artifacts/src") });
//});
appbuilder.UseStaticFiles(new StaticFileOptions {
FileProvider = new PhysicalFileProvider(HostFolder)
});
})
.Build();
await host.StartAsync();;
if (HelloWorld)
{
Url = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses
.Select(a => a.Replace("://+", "://localhost").Replace("[::]", "127.0.0.1")).FirstOrDefault() + "/hello-world";
}
if (!string.IsNullOrEmpty(RemotePageLocation))
{
Url = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses
.Select(a => a.Replace("://+", "://localhost").Replace("[::]", "127.0.0.1")).FirstOrDefault() + $"?remote-main={RemotePageMain}&remote-location={WebUtility.UrlEncode(RemotePageLocation)}";
}
{
var services = new ServiceCollection();
services.AddNodeServices(a =>
{
// a.ProjectPath = Directory.GetCurrentDirectory();
// Set any properties that you want on 'options' here
});
var serviceProvider = services.BuildServiceProvider();
var options = new NodeServicesOptions(serviceProvider)
{
ProjectPath = HostFolder,
InvocationTimeoutMilliseconds = 60000 * 10,
WatchFileExtensions = new string[] { }
};
var _nodeServices = NodeServicesFactory.CreateNodeServices(options);
try
{
var data = await RequireJS.RunAsync <object, JToken>(_nodeServices, HostFolder, "earthml-temply-headless/Headless/headless", new
{
url = Url,
headlessHost = host.ServerFeatures.Get <IServerAddressesFeature>().Addresses
.Select(a => a.Replace("://+", "://localhost").Replace("[::]", "127.0.0.1")).FirstOrDefault(),
headless = true,
size = new
{
width = Width,
height = Height
},
data = args,
inputPrefix = InputFolder,
outputPrefix = OutputFolder
});
Console.WriteLine(data.ToString());
}catch (Exception ex)
{
Console.WriteLine(ex);
await Task.Delay(60000);
}
}
if (host != null)
{
await host.StopAsync();
}
return(0);
}
private INodeInstance CreateNodeInstance(NodeServicesOptions options)
{
return(new HttpNodeInstance(options, /* port */ 0));
}
/// <summary>
/// Configures the <see cref="INodeServices"/> service so that it will use out-of-process
/// Node.js instances and perform RPC calls over HTTP.
/// </summary>
public static void UseHttpHosting(this NodeServicesOptions options)
{
options.NodeInstanceFactory = () => new HttpNodeInstance(options);
}
/// <summary>
/// Enables Webpack dev middleware support. This hosts an instance of the Webpack compiler in memory
/// in your application so that you can always serve up-to-date Webpack-built resources without having
/// to run the compiler manually. Since the Webpack compiler instance is retained in memory, incremental
/// compilation is vastly faster that re-running the compiler from scratch.
///
/// Incoming requests that match Webpack-built files will be handled by returning the Webpack compiler
/// output directly, regardless of files on disk. If compilation is in progress when the request arrives,
/// the response will pause until updated compiler output is ready.
/// </summary>
/// <param name="appBuilder">The <see cref="IApplicationBuilder"/>.</param>
/// <param name="options">Options for configuring the Webpack compiler instance.</param>
public static void UseWebpackDevMiddleware(
this IApplicationBuilder appBuilder,
WebpackDevMiddlewareOptions options = null)
{
// Prepare options
if (options == null)
{
options = new WebpackDevMiddlewareOptions();
}
// Validate options
if (options.ReactHotModuleReplacement && !options.HotModuleReplacement)
{
throw new ArgumentException(
"To enable ReactHotModuleReplacement, you must also enable HotModuleReplacement.");
}
// Unlike other consumers of NodeServices, WebpackDevMiddleware dosen't share Node instances, nor does it
// use your DI configuration. It's important for WebpackDevMiddleware to have its own private Node instance
// because it must *not* restart when files change (if it did, you'd lose all the benefits of Webpack
// middleware). And since this is a dev-time-only feature, it doesn't matter if the default transport isn't
// as fast as some theoretical future alternative.
var nodeServicesOptions = new NodeServicesOptions(appBuilder.ApplicationServices);
nodeServicesOptions.WatchFileExtensions = new string[] { }; // Don't watch anything
if (!string.IsNullOrEmpty(options.ProjectPath))
{
nodeServicesOptions.ProjectPath = options.ProjectPath;
}
if (options.EnvironmentVariables != null)
{
foreach (var kvp in options.EnvironmentVariables)
{
nodeServicesOptions.EnvironmentVariables[kvp.Key] = kvp.Value;
}
}
var nodeServices = NodeServicesFactory.CreateNodeServices(nodeServicesOptions);
// Get a filename matching the middleware Node script
var script = EmbeddedResourceReader.Read(typeof(WebpackDevMiddleware),
"/Content/Node/webpack-dev-middleware.js");
var nodeScript = new StringAsTempFile(script, nodeServicesOptions.ApplicationStoppingToken); // Will be cleaned up on process exit
// Ideally, this would be relative to the application's PathBase (so it could work in virtual directories)
// but it's not clear that such information exists during application startup, as opposed to within the context
// of a request.
var hmrEndpoint = !string.IsNullOrEmpty(options.HotModuleReplacementEndpoint)
? options.HotModuleReplacementEndpoint
: "/__webpack_hmr"; // Matches webpack's built-in default
// Tell Node to start the server hosting webpack-dev-middleware
var devServerOptions = new
{
webpackConfigPath = Path.Combine(nodeServicesOptions.ProjectPath, options.ConfigFile ?? DefaultConfigFile),
suppliedOptions = options,
understandsMultiplePublicPaths = true,
hotModuleReplacementEndpointUrl = hmrEndpoint
};
var devServerInfo =
nodeServices.InvokeExportAsync <WebpackDevServerInfo>(nodeScript.FileName, "createWebpackDevServer",
JsonConvert.SerializeObject(devServerOptions, jsonSerializerSettings)).Result;
// If we're talking to an older version of aspnet-webpack, it will return only a single PublicPath,
// not an array of PublicPaths. Handle that scenario.
if (devServerInfo.PublicPaths == null)
{
devServerInfo.PublicPaths = new[] { devServerInfo.PublicPath };
}
// Proxy the corresponding requests through ASP.NET and into the Node listener
// Anything under /<publicpath> (e.g., /dist) is proxied as a normal HTTP request with a typical timeout (100s is the default from HttpClient),
// plus /__webpack_hmr is proxied with infinite timeout, because it's an EventSource (long-lived request).
foreach (var publicPath in devServerInfo.PublicPaths)
{
appBuilder.UseProxyToLocalWebpackDevMiddleware(publicPath + hmrEndpoint, devServerInfo.Port, Timeout.InfiniteTimeSpan);
appBuilder.UseProxyToLocalWebpackDevMiddleware(publicPath, devServerInfo.Port, TimeSpan.FromSeconds(100));
}
}
/// <summary>
/// Configures the <see cref="INodeServices"/> service so that it will use out-of-process
/// Node.js instances and perform RPC calls over binary sockets (on Windows, this is
/// implemented as named pipes; on other platforms it uses domain sockets).
/// </summary>
public static void UseSocketHosting(this NodeServicesOptions options)
{
var pipeName = "pni-" + Guid.NewGuid().ToString("D"); // Arbitrary non-clashing string
options.NodeInstanceFactory = () => new SocketNodeInstance(options, pipeName);
}
/// <summary>
/// Initializes a new instance of the <see cref="NodeRenderEngineOptions"/> class.
/// </summary>
public NodeRenderEngineOptions()
{
WatchFileExtensions = new NodeServicesOptions().WatchFileExtensions;
NodeHostingModel = NodeHostingModel.Http;
}
/// <summary>
/// Sends a message using Gmail API
/// </summary>
/// <param name="msg">Message to send</param>
/// <returns>JSON serialized string of a result object</returns>
public string Send(EmailMessage msg)
{
string emailTemplate = GetMsgTemplate(msg.template.templateId);
if (null == emailTemplate)
{
_logger.LogError($"Unable to load Email template with id {msg.template.templateId}");
return(null);
}
string htmlBody = null;
string subject = null;
ServiceCollection services = new ServiceCollection();
services.AddNodeServices();
using (ServiceProvider serviceProvider = services.BuildServiceProvider())
{
NodeServicesOptions options = new NodeServicesOptions(serviceProvider) /* Assign/override any other options here */ }
{
;
using (INodeServices nodeServices = NodeServicesFactory.CreateNodeServices(options))
{
htmlBody = nodeServices.InvokeAsync <string>("pugcompile", emailTemplate, null == msg.bodyModel ? null: JsonConvert.DeserializeObject(msg.bodyModel)).Result;
subject = nodeServices.InvokeAsync <string>("pugcompile", msg.template.subjectTemplate, null == msg.subjectModel ? null : JsonConvert.DeserializeObject(msg.subjectModel)).Result;
}
}
services.Clear();
if (null == subject)
{
_logger.LogError($"Unable to load email subject");
return(null);
}
if (null == emailTemplate)
{
_logger.LogError($"Unable to load Email template with id {msg.template.templateId}");
return(null);
}
UserCredential credential;
string[] scopes = { GmailService.Scope.GmailSend };
using (FileStream stream = new FileStream("credentials.json", FileMode.Open, FileAccess.Read))
{
// The file token.json stores the user's access and refresh tokens, and is created
// automatically when the authorization flow completes for the first time.
string credPath = "token.json";
credential = GoogleWebAuthorizationBroker.AuthorizeAsync(
GoogleClientSecrets.Load(stream).Secrets,
scopes,
"user",
CancellationToken.None,
new FileDataStore(credPath, true)).Result;
_logger.LogInformation("Google credential file saved to: " + credPath);
}
// Create Gmail API service.
using (GmailService service = new GmailService(new BaseClientService.Initializer()
{
HttpClientInitializer = credential,
ApplicationName = "MailGmail",
}))
{
Google.Apis.Gmail.v1.Data.Message message = CreateGmailMessage(msg.from, msg.to, subject, htmlBody);
Google.Apis.Gmail.v1.Data.Message messageResult = service.Users.Messages.Send(message, "me").Execute();
return(JsonConvert.SerializeObject(messageResult));
}
}
