protected override NodeInstalledPackage CreatePackage(PackagePath pp)
{
var options = this._Options.NodeServicesOptions ?? new NodeServicesOptions(services)
{
ProjectPath = pp.TagFolder,
NodeInstanceOutputLogger = services.GetService <ILogger <NodePackageService> >()
};
options.ProjectPath = pp.TagFolder;
if (this.Options.EnvironmentVariables != null)
{
if (options.EnvironmentVariables == null)
{
options.EnvironmentVariables = new Dictionary <string, string>();
}
foreach (var item in this.Options.EnvironmentVariables)
{
options.EnvironmentVariables[item.Key] = item.Value;
}
}
var s = NodeServicesFactory.CreateNodeServices(options);
return(new NodePackage {
Path = pp,
NodeServices = s
});
}
protected override NodeInstalledPackage CreatePackage(PackagePath pp)
{
//var options = this._Options.NodeServicesOptions ?? new NodeJSProcessOptions()
//{
// ProjectPath = pp.TagFolder,
// NodeInstanceOutputLogger = services.GetService<ILogger<NodePackageService>>()
//};
ver options = services.Configure <NodeJSProcessOptions>();
options.ProjectPath = pp.TagFolder;
if (this.Options.EnvironmentVariables != null)
{
if (options.EnvironmentVariables == null)
{
options.EnvironmentVariables = new Dictionary <string, string>();
}
foreach (var item in this.Options.EnvironmentVariables)
{
options.EnvironmentVariables[item.Key] = item.Value;
}
}
var s = services.GetRequiredService <INodeJSService>();
return(new NodePackage {
Path = pp,
NodeServices = s
});
}
public async Task InstallAsync(PackagePath packagePath)
{
if (this.Options.UseFileLock)
{
using (var fl = await NFileLock.AcquireAsync(
packagePath.TagFolder + "_lock",
TimeSpan.FromMinutes(15)))
{
if (Directory.Exists(packagePath.TagFolder))
{
return;
}
await DownloadAsync(packagePath);
return;
}
}
bool wait = false;
while (true)
{
lock (loading)
{
if (loading.ContainsKey(packagePath.TagFolder))
{
wait = true;
}
else
{
wait = false;
loading[packagePath.TagFolder] = true;
break;
}
}
if (wait)
{
await Task.Delay(1000);
}
}
try
{
if (!Directory.Exists(packagePath.TagFolder))
{
await DownloadAsync(packagePath);
}
}
finally
{
lock (loading)
{
loading.Remove(packagePath.TagFolder);
}
}
}
public async Task DownloadAsync(PackagePath packagePath)
{
if (!Directory.Exists(packagePath.TagFolder))
{
using (var tgz = new PackageInstallTask(packagePath))
{
await tgz.RunAsync();
}
}
}
public async Task <NodeInstalledPackage> InstalledPackageAsync(string path)
{
PackagePathSegments pps = path;
pps = await this.ResolveVersion(pps);
var pp = new PackagePath(this.Options, pps, true);
return(await cache.GetAsync(pp.Package + "@" + pp.Version, async entry => {
entry.SlidingExpiration = this.Options.TTL;
await InstallAsync(pp);
var p = CreatePackage(pp);
entry.EvictionCallbacks.Add((a) => {
p.Dispose();
});
return p;
}));
}
public static IApplicationBuilder UseUIViews(this IApplicationBuilder app, string route = "uiv/")
{
app.Use(async(context, next) =>
{
HttpRequest request = context.Request;
if (!request.Method.EqualsIgnoreCase("GET"))
{
await next();
return;
}
PathString path = request.Path;
if (!path.HasValue || !path.Value.StartsWithIgnoreCase(route))
{
await next();
return;
}
IHeaderDictionary headers = context.Response.Headers;
headers.Add("access-control-allow-origin", "*");
headers.Add("access-control-expose-headers", "*");
headers.Add("access-control-allow-methods", "*");
headers.Add("access-control-allow-headers", "*");
headers.Add("access-control-max-age", TimeSpan.FromDays(30).TotalSeconds.ToString());
var nodeServer = context.RequestServices.GetService <NodePackageService>();
string sp = path.Value.Substring(4);
PackagePath packagePath = nodeServer.ParsePath(sp);
await nodeServer.DownloadAsync(packagePath);
// get file content...
});
return(app);
}
public async Task InstallAsync(PackagePath packagePath)
{
bool wait = false;
while (true)
{
lock (loading)
{
if (loading.ContainsKey(packagePath.TagFolder))
{
wait = true;
}
else
{
wait = false;
loading[packagePath.TagFolder] = true;
break;
}
}
if (wait)
{
await Task.Delay(1000);
}
}
try
{
if (!Directory.Exists(packagePath.TagFolder))
{
await DownloadAsync(packagePath);
}
} finally {
lock (loading)
{
loading.Remove(packagePath.TagFolder);
}
}
}
protected virtual NodeInstalledPackage CreatePackage(PackagePath pp)
{
return(new NodeInstalledPackage {
Path = pp
});
}
