/// <summary>
/// Constructor.
/// </summary>
/// <param name="project">Project.</param>
/// <param name="pathResolver">File path resolver.</param>
/// <param name="settings">Settings.</param>
public NodeLauncher(NodeProjectNode project, IPathResolver pathResolver, ISettingsProvider settings)
{
Utilities.ArgumentNotNull("project", project);
_project = project;
_pathResolver = pathResolver;
_settings = settings;
}
public SiteManager(IPathResolver pathResolver, bool traceFailedRequests, string logPath, ISettingsResolver settingsResolver)
{
_logPath = logPath;
_pathResolver = pathResolver;
_traceFailedRequests = traceFailedRequests;
_settingsResolver = settingsResolver;
}
public BeatrixControllerFactory(IPageRepository pageRepository, IPathResolver pathResolver)
: base()
{
this.pageRepository = pageRepository;
this.pathResolver = pathResolver;
this.beatrixControllerTypes = ReflectBeatrixControllers();
}
public WindowManager(IPathResolver pathResolver, DockPanel dockPanel, Settings settings)
{
m_settings = settings;
m_fileEditorMap = new Dictionary<string, EditorContentBox>();
m_pathResolver = pathResolver;
m_dockPanel = dockPanel;
}
public MapDataLoader(IElevationProvider elevationProvider, IFileSystemService fileSystemService,
ImaginaryProvider imaginaryProvider, IPathResolver pathResolver)
{
_elevationProvider = elevationProvider;
_fileSystemService = fileSystemService;
_imaginaryProvider = imaginaryProvider;
_pathResolver = pathResolver;
}
public LessFileTransformerFileReader(
IPathResolver pathResolver,
IEnumerable<IFileTransformer> transformers,
IFileSystem fileSystem)
{
_pathResolver = pathResolver;
_transformers = transformers;
_fileSystem = fileSystem;
}
/// <summary>
/// Initializes a new instance of the <see cref="WebAssetLocator"/> class.
/// </summary>
/// <param name="isInDebugMode">if set to <c>true</c> [is in debug mode].</param>
/// <param name="pathResolver">The path resolver.</param>
/// <param name="fileSystem">The file system.</param>
public WebAssetLocator(bool isInDebugMode, IPathResolver pathResolver, IFileSystem fileSystem)
{
Guard.IsNotNull(pathResolver, "pathResolver");
Guard.IsNotNull(fileSystem, "fileSystem");
this.isInDebugMode = isInDebugMode;
this.pathResolver = pathResolver;
this.fileSystem = fileSystem;
}
public AvatarService(IPathResolver pathResolver, IFileSystem fileSystemProvider)
{
_pathResolver = pathResolver;
_fileSystemProvider = fileSystemProvider;
_avatarDirectoryInfo = _fileSystemProvider.GetDirectory("avatars");
if (!_avatarDirectoryInfo.Exists)
_avatarDirectoryInfo.Create();
}
public CoffeeHandlerImpl(IHttp http, IResponse response,
ICoffeeEngine engine, IPathResolver resolver)
{
Http = http;
Response = response;
mEngine = engine;
mResolver = resolver;
}
/// <summary>
/// Initializes a new instance of the <see cref="Host"/> class.
/// </summary>
/// <param name="transformer">The transformer.</param>
/// <param name="pathResolver">The path resolver.</param>
/// <param name="fileLoader">The file loader.</param>
internal Host(ITextTransformer transformer, IPathResolver pathResolver, IFileLoader fileLoader)
{
if (transformer == null) throw new ArgumentNullException("transformer");
if (pathResolver == null) throw new ArgumentNullException("pathResolver");
if (fileLoader == null) throw new ArgumentNullException("fileLoader");
_transformer = transformer;
_pathResolver = pathResolver;
_fileLoader = fileLoader;
}
public XmlSiteMap(IPathResolver pathResolver, IVirtualPathProvider provider, ICacheProvider cacheProvider)
{
Check.Argument.IsNotNull(pathResolver, "pathResolver");
Check.Argument.IsNotNull(provider, "fileSystem");
Check.Argument.IsNotNull(cacheProvider, "cacheProvider");
this.pathResolver = pathResolver;
this.provider = provider;
this.cacheProvider = cacheProvider;
}
public ProviderContext(CmdletProvider provider, string path, PSDriveInfo drive, IPathResolver pathProcessor, object dynamicParameters, Version topology, bool recurse)
{
this.pathProcessor = pathProcessor;
DynamicParameters = dynamicParameters;
this.provider = provider;
this.path = path;
this.drive = drive;
this.recurse = recurse;
PathTopologyVersion = topology;
}
public PackageProcessing(IPathResolver resolver, Packages packages)
{
Reporting = new ErrorReporting();
// Process after setting up Info, Warn, and Errs
ProcessPackage(packages, Reporting);
Content = new ContentProvider(resolver, Reporting);
Packages = ProcessPackageReferences(packages, Reporting, new HashSet<string>());
}
public CoffeeEngine(IPathResolver pathResolver, string compilerPath, string compilerArguments)
{
mCompilerArguments = compilerArguments;
if (Path.IsPathRooted(compilerPath)) {
mCompilerPath = compilerPath;
} else {
var root = pathResolver.GetFullPath("/");
mCompilerPath = Path.Combine(root, compilerPath);
}
}
public ContentRoute(IPathResolver pathResolver, IVirtualPathResolver virtualPathResolver, Route innerRoute)
{
_pathResolver = pathResolver;
_virtualPathResolver = virtualPathResolver;
_routeHandler = _routeHandler ?? new MvcRouteHandler();
_innerRoute = innerRoute ?? new Route("dashboard/{controller}/{action}",
new RouteValueDictionary(new { controller = "content", action = "index" }),
new RouteValueDictionary(),
new RouteValueDictionary(new { area = "Dashboard" }),
new MvcRouteHandler());
}
/// <summary>
/// Initializes a new instance of the <see cref="PageRoute"/> class.
/// </summary>
/// <param name="pathResolver">The path resolver.</param>
/// <param name="virtualPathResolver">The virtual path resolver.</param>
/// <param name="innerRoute">The inner route.</param>
public PageRoute(IPathResolver pathResolver, IVirtualPathResolver virtualPathResolver, Route innerRoute)
{
_pathResolver = pathResolver;
_virtualPathResolver = virtualPathResolver;
_routeHandler = _routeHandler ?? new MvcRouteHandler();
_innerRoute = innerRoute ?? new Route("{controller}/{action}",
new RouteValueDictionary(new { action = "index" }),
new RouteValueDictionary(),
new RouteValueDictionary(),
_routeHandler);
}
public EditorContentBox(IPathResolver pathResolver)
{
m_pathResolver = pathResolver;
m_baseTitle = MakeGenericFileName();
InitializeComponent();
// scintilla control settings
var confMgr = scintilla.ConfigurationManager;
confMgr.CustomLocation = m_pathResolver.Resolve(CONFIG_XML_REL_PATH);
confMgr.Language = "default";
}
/// <summary>
/// Initializes a new instance of the <see cref="WebAssetRegistry"/> class.
/// </summary>
/// <param name="cacheManager">The cache manager.</param>
/// <param name="assetLocator">The asset locator.</param>
/// <param name="pathResolver">The path resolver.</param>
/// <param name="fileSystem">The file system.</param>
public WebAssetRegistry(ICacheManager cacheManager, IWebAssetLocator assetLocator, IPathResolver pathResolver, IFileSystem fileSystem)
{
Guard.IsNotNull(cacheManager, "cacheManager");
Guard.IsNotNull(assetLocator, "assetLocator");
Guard.IsNotNull(pathResolver, "pathResolver");
Guard.IsNotNull(fileSystem, "fileSystem");
this.cacheManager = cacheManager;
this.assetLocator = assetLocator;
this.pathResolver = pathResolver;
this.fileSystem = fileSystem;
}
public static DateTime LastModified(this ConfigurationSection configSection, IPathResolver pathResolver)
{
string configSource = configSection.SectionInformation.ConfigSource;
string configFile;
if (String.IsNullOrEmpty(configSource))
configFile = "~/web.config";
else
configFile = "~/" + configSource;
string filePath = pathResolver.MapPath(configFile);
return File.GetLastWriteTime(filePath).ToUniversalTime();
}
public ThumbnailCacheService(ISettingsProvider<WebSettings> settings,
IPathResolver pathResolver,
IPostThumbnailService postThumbnailService)
{
_postThumbnailService = postThumbnailService;
_thumbnailCacheDirectory = pathResolver.Resolve(settings.Settings.ThumbnailCache);
foreach (string type in Enum.GetValues(typeof(ThumbnailType)).Cast<ThumbnailType>().Select(x => x.ToString()))
{
var cacheDirectory = Path.Combine(_thumbnailCacheDirectory, type);
if (!Directory.Exists(cacheDirectory))
Directory.CreateDirectory(cacheDirectory);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="WebAssetRegistry"/> class.
/// </summary>
/// <param name="isInDebugMode">if set to <c>true</c> [is in debug mode].</param>
/// <param name="cacheManager">The cache manager.</param>
/// <param name="assetLocator">The asset locator.</param>
/// <param name="urlResolver">The URL resolver.</param>
/// <param name="pathResolver">The path resolver.</param>
/// <param name="virtualPathProvider">The virtual path provider.</param>
public WebAssetRegistry(bool isInDebugMode, ICacheManager cacheManager, IWebAssetLocator assetLocator, IUrlResolver urlResolver, IPathResolver pathResolver, IVirtualPathProvider virtualPathProvider)
{
Guard.IsNotNull(cacheManager, "cacheManager");
Guard.IsNotNull(assetLocator, "assetLocator");
Guard.IsNotNull(urlResolver, "urlResolver");
Guard.IsNotNull(pathResolver, "pathResolver");
Guard.IsNotNull(virtualPathProvider, "virtualPathProvider");
this.isInDebugMode = isInDebugMode;
this.cacheManager = cacheManager;
this.assetLocator = assetLocator;
this.urlResolver = urlResolver;
this.pathResolver = pathResolver;
this.virtualPathProvider = virtualPathProvider;
}
public IronScriptManager(string mainScript, IPathResolver pathResolver, Settings settings)
{
m_settings = settings;
m_pathResolver = pathResolver;
m_mainScript = m_pathResolver.Resolve(mainScript);
// Create script file if it doesn't exist
if (!File.Exists(m_mainScript))
{
var stream = File.CreateText(m_mainScript);
stream.Dispose();
}
// Create ruby engine
m_engine = CreateAndInitEngine();
}
public MainForm(IPathResolver pathResolver, IScriptManager scriptManager, Settings settings)
{
m_settings = settings;
m_pathResolver = pathResolver;
m_scriptMgr = scriptManager;
InitializeComponent();
// Window manager
m_windowMgr = new WindowManager(m_pathResolver, dockPanel, m_settings);
m_windowMgr.OnCaretChanged += new EventHandler<CaretChangedEventArgs>(WindowManagerOnCaretChanged);
// Post component initialization
openFileDialog.InitialDirectory = m_pathResolver.BaseDirectory;
// Load output window
m_outputContent = new OutputContentBox();
m_outputContent.Show(dockPanel, DockState.DockBottom);
// Load error window
m_errorContent = new ErrorContentBox();
m_errorContent.Show(dockPanel, DockState.DockBottom);
m_errorContent.ErrorSelected += new EventOnErrorSelected(OnErrorSelected);
// Adjust bottom panel
dockPanel.DockBottomPortion = m_settings.DockBottom;
dockPanel.DockRightPortion = m_settings.DockRight;
dockPanel.DockLeftPortion = m_settings.DockLeft;
dockPanel.DockTopPortion = m_settings.DockTop;
// Attach event handlers
m_scriptMgr.CompileFinished += new EventHandler(OnCompileFinished);
m_scriptMgr.CompileInterrupted += new EventHandler(OnCompileInterrupted);
m_scriptMgr.CompileStarting += new EventHandler(OnCompileStarting);
m_scriptMgr.ScriptError += new EventHandler<ScriptErrorEventArgs>(OnScriptError);
m_scriptMgr.ScriptOutput += new EventHandler<ScriptOutputEventArgs>(OnScriptOutput);
m_scriptMgr.ScriptEngineRestarted += new EventHandler(OnScriptEngineRestarted);
m_scriptMgr.ScriptEngineRestarting += new EventHandler(OnScriptEngineRestarting);
// Disable Windows-XP default theme; use system colours
ToolStripProfessionalRenderer renderer = new ToolStripProfessionalRenderer();
renderer.ColorTable.UseSystemColors = true;
renderer.RoundedEdges = true;
ToolStripManager.Renderer = renderer;
}
/// <summary>
/// Initializes a new instance of the <see cref="DirectorySearcher" /> class.
/// </summary>
/// <param name="path">The path.</param>
/// <param name="searchPattern">The search pattern.</param>
/// <param name="recursive">if set to <c>true</c> [recursive].</param>
/// <param name="pathResolver">The path resolver.</param>
/// <param name="keyGenerator">The key generator.</param>
/// <param name="rules">The rules.</param>
public DirectorySearcher(
IConfigurationProvider configurationProvider,
IPathResolver pathResolver,
IKeyGenerator keyGenerator,
IFileSystemProvider fileProvider,
string path,
string searchPattern,
bool recursive,
params IIncludeConfigurationRule[] rules)
{
this.ConfigurationProvider = configurationProvider;
this.Path = path;
this.SearchPattern = searchPattern;
this.Recursive = recursive;
this.PathResolver = pathResolver;
this.KeyGenerator = keyGenerator;
this.Rules = rules;
}
public HttpCache(IHttp http, IPathResolver pathResolver)
{
_http = http;
PathResolver = pathResolver;
}
public bool ContainsModule(IFileSystem fileSystem, IPathResolver pathResolver, string resolved_id)
{
return(OnValidating(resolved_id) && fileSystem.Exists(resolved_id));
}
protected abstract bool OnResolvingFile(IFileSystem fileSystem, IPathResolver pathResolver, string fileName, out string searchPath, out string resolvedFileName);
public static string GetUnresolvedFilePathAndResolve(string sourcePath, string relativeFilePath, IPathResolver pathResolver)
{
var resolvedPath = PathResolverTestFixture.GetUnresolvedPathAndResolve(sourcePath, relativeFilePath,
(x) => pathResolver.ResolveFilePath(x));
return(resolvedPath);
}
public DynamoMigrator08(IPathResolver pathResolver, FileVersion version)
: base(pathResolver, version)
{
}
public LinuxDllImportLibraryPathResolver(IPathResolver original)
{
_original = original;
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app,
IHostingEnvironment env,
ILoggerFactory loggerFactory,
IPathResolver pathResolver)
{
loggerFactory.AddSerilog();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseExceptionHandler("/Home/Error");
}
app.ApplicationServices.GetService <Data.Context>().Migrate();
app.UseResponseCompression();
// configure static files with 7 day cache
app.UseStaticFiles(new StaticFileOptions()
{
OnPrepareResponse = _ =>
{
var headers = _.Context.Response.GetTypedHeaders();
headers.CacheControl = new Microsoft.Net.Http.Headers.CacheControlHeaderValue()
{
MaxAge = TimeSpan.FromDays(7)
};
}
});
string contentPath = pathResolver.ResolveContentFilePath();
if (!Directory.Exists(contentPath))
{
try
{
Directory.CreateDirectory(contentPath);
}
catch (Exception ex)
{
Console.WriteLine($"Unable to create directory '{contentPath}' in {Directory.GetCurrentDirectory()}");
throw (ex);
}
}
string pathString = pathResolver.ResolveContentPath();
if (!pathString.StartsWith("/"))
{
pathString = "/" + pathString;
}
// configure /content with 7 day cache
app.UseStaticFiles(new StaticFileOptions()
{
FileProvider = new PhysicalFileProvider(contentPath),
RequestPath = new PathString(pathString),
OnPrepareResponse = _ =>
{
var headers = _.Context.Response.GetTypedHeaders();
headers.CacheControl = new Microsoft.Net.Http.Headers.CacheControlHeaderValue()
{
MaxAge = TimeSpan.FromDays(7)
};
}
});
app.UseSession();
// set cookie authentication options
var cookieAuthOptions = new CookieAuthenticationOptions
{
AuthenticationScheme = Controllers.Authentication.SchemeGRACookie,
LoginPath = new PathString("/SignIn/"),
AccessDeniedPath = new PathString("/"),
AutomaticAuthenticate = true,
AutomaticChallenge = true
};
// if there's a data protection path, set it up - for clustered/multi-server configs
if (!string.IsNullOrEmpty(Configuration[ConfigurationKey.DataProtectionPath]))
{
string protectionPath = Configuration[ConfigurationKey.DataProtectionPath];
cookieAuthOptions.DataProtectionProvider = DataProtectionProvider.Create(
new DirectoryInfo(Path.Combine(protectionPath, "cookies")));
}
app.UseCookieAuthentication(cookieAuthOptions);
// sitePath is also referenced in GRA.Controllers.Filter.SiteFilter
app.UseMvc(routes =>
{
routes.MapRoute(
name: null,
template: "{area:exists}/{controller=Home}/{action=Index}/{id?}");
routes.MapRoute(
name: null,
template: "{sitePath}/Info/{stub}",
defaults: new { controller = "Info", action = "Index" },
constraints: new
{
sitePath = new SiteRouteConstraint(app.ApplicationServices.GetRequiredService <Controllers.Base.ISitePathValidator>())
});
routes.MapRoute(
name: null,
template: "Info/{stub}",
defaults: new { controller = "Info", action = "Index" });
routes.MapRoute(
name: null,
template: "{sitePath}/{controller}/{action}/{id?}",
defaults: new { controller = "Home", action = "Index" },
constraints: new
{
sitePath = new SiteRouteConstraint(app.ApplicationServices.GetRequiredService <Controllers.Base.ISitePathValidator>())
});
routes.MapRoute(
name: null,
template: "{controller=Home}/{action=Index}/{id?}");
});
}
public TransferCacheService(IFileSystem fileSystem, IChecksumService checksumService, IPathResolver pathResolver, Logger logger)
{
_fileSystem = fileSystem;
_checksumService = checksumService;
_pathResolver = pathResolver;
_logger = logger;
}
public InstalledPackagesStore(IFileSystem fileSystem, IPathResolver pathResolver)
: base(fileSystem, pathResolver)
{
}
public ProcessUncompressedFilesCommand(IntermediateSection section, IBackendHelper backendHelper, IPathResolver pathResolver)
{
this.Section = section;
this.BackendHelper = backendHelper;
this.PathResolver = pathResolver;
}
public OnDemandAnimationLoader(IPathResolver pathResolver)
{
_pathResolver = pathResolver;
}
public InstallerArgFactory(Logger logger, IPathResolver pathResolver)
{
_logger = logger;
_pathResolver = pathResolver;
}
public MapDataLibrary(MaterialProvider materialProvider, IPathResolver pathResolver, ITrace trace)
{
_materialProvider = materialProvider;
_pathResolver = pathResolver;
_trace = trace;
}
public WorksheetManager(IDbToolSettings settings, IPathResolver pathResolver)
{
_settings = settings;
_pathResolver = pathResolver;
}
public SiteManager(IPathResolver pathResolver)
: this(pathResolver, traceFailedRequests: false, logPath: null)
{
}
public FileWatchDistributedNotificationReceiver(IPathResolver pathResolver)
{
Directory.CreateDirectory(pathResolver.ConfigurationFolder);
_targetDirectory = pathResolver.ConfigurationFolder;
}
static DynamicLinkLibraryPathResolver()
{
LocalPathResolver = new LocalPathResolver();
PathResolver = SelectPathResolver();
}
public static void WriteDistributedNotificationToPath(string base64Notification, IPathResolver pathResolver)
{
Directory.CreateDirectory(pathResolver.ConfigurationFolder);
var targetPath = Path.Combine(pathResolver.ConfigurationFolder, $"{Guid.NewGuid().ToString()}.{FileExtension}");
try
{
Log.Info().Message($"Writing distributed message to path \"{targetPath}\".").Write();
File.WriteAllText(targetPath, base64Notification);
}
catch (Exception e)
{
Log.Error().Message("Failed to serialize and write DistributedNotification.").Exception(e).Write();
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app,
IHostingEnvironment env,
ILoggerFactory loggerFactory,
IPathResolver pathResolver,
RoleService roleService,
SiteLookupService siteLookupService)
{
loggerFactory.AddSerilog();
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
app.UseBrowserLink();
}
else
{
app.UseStatusCodePagesWithReExecute("/Error/Index/{0}");
}
var dbContext = app.ApplicationServices.GetService <Data.Context>();
try
{
var pending = dbContext.GetPendingMigrations();
if (pending != null && pending.Count() > 0)
{
Log.Logger.Warning($"Applying {pending.Count()} database migrations, last is: {pending.Last()}");
}
}
catch (Exception ex)
{
Log.Logger.Error($"Error looking up migrations to perform: {ex.Message}");
}
dbContext.Migrate();
Task.Run(() => siteLookupService.GetDefaultSiteIdAsync()).Wait();
Task.Run(() => roleService.SyncPermissionsAsync()).Wait();
app.UseRequestLocalization();
app.UseResponseCompression();
// configure static files with 7 day cache
app.UseStaticFiles(new StaticFileOptions()
{
OnPrepareResponse = _ =>
{
var headers = _.Context.Response.GetTypedHeaders();
headers.CacheControl = new Microsoft.Net.Http.Headers.CacheControlHeaderValue()
{
MaxAge = TimeSpan.FromDays(7)
};
}
});
string contentPath = pathResolver.ResolveContentFilePath();
if (!Directory.Exists(contentPath))
{
try
{
Directory.CreateDirectory(contentPath);
}
catch (Exception ex)
{
Console.WriteLine($"Unable to create directory '{contentPath}' in {Directory.GetCurrentDirectory()}");
throw (ex);
}
}
string pathString = pathResolver.ResolveContentPath();
if (!pathString.StartsWith("/"))
{
pathString = "/" + pathString;
}
// configure /content with 7 day cache
app.UseStaticFiles(new StaticFileOptions()
{
FileProvider = new PhysicalFileProvider(contentPath),
RequestPath = new PathString(pathString),
OnPrepareResponse = _ =>
{
var headers = _.Context.Response.GetTypedHeaders();
headers.CacheControl = new Microsoft.Net.Http.Headers.CacheControlHeaderValue()
{
MaxAge = TimeSpan.FromDays(7)
};
}
});
app.UseSession();
// set cookie authentication options
var cookieAuthOptions = new CookieAuthenticationOptions
{
AuthenticationScheme = Controllers.Authentication.SchemeGRACookie,
LoginPath = new PathString("/SignIn/"),
AccessDeniedPath = new PathString("/"),
AutomaticAuthenticate = true,
AutomaticChallenge = true
};
// if there's a data protection path, set it up - for clustered/multi-server configs
if (!string.IsNullOrEmpty(Configuration[ConfigurationKey.DataProtectionPath]))
{
string protectionPath = Configuration[ConfigurationKey.DataProtectionPath];
cookieAuthOptions.DataProtectionProvider = DataProtectionProvider.Create(
new DirectoryInfo(Path.Combine(protectionPath, "cookies")));
}
app.UseCookieAuthentication(cookieAuthOptions);
// sitePath is also referenced in GRA.Controllers.Filter.SiteFilter
app.UseMvc(routes =>
{
routes.MapRoute(
name: null,
template: "{area:exists}/{controller=Home}/{action=Index}/{id?}");
routes.MapRoute(
name: null,
template: "{sitePath}/Info/{stub}",
defaults: new { controller = "Info", action = "Index" },
constraints: new
{
sitePath = new SiteRouteConstraint(app.ApplicationServices.GetRequiredService <Controllers.Base.ISitePathValidator>())
});
routes.MapRoute(
name: null,
template: "Info/{stub}",
defaults: new { controller = "Info", action = "Index" });
routes.MapRoute(
name: null,
template: "{sitePath}/{controller}/{action}/{id?}",
defaults: new { controller = "Home", action = "Index" },
constraints: new
{
sitePath = new SiteRouteConstraint(app.ApplicationServices.GetRequiredService <Controllers.Base.ISitePathValidator>())
});
routes.MapRoute(
name: null,
template: "{controller=Home}/{action=Index}/{id?}");
});
app.UseWebSockets(new WebSocketOptions
{
KeepAliveInterval = TimeSpan.FromSeconds(30)
});
app.Use(async(context, next) =>
{
if (context.WebSockets.IsWebSocketRequest)
{
var handler = app.ApplicationServices.GetService <WebSocketHandler>();
await handler.Handle(context);
}
else
{
await next();
}
});
}
public void Initialize(IFileSystem fileSystem, IPathResolver resolver, IScriptRuntimeListener listener, IAsyncManager asyncManager, IScriptLogger logger, IO.IByteBufferAllocator byteBufferAllocator)
{
if (logger == null)
{
throw new NullReferenceException(nameof(logger));
}
if (fileSystem == null)
{
throw new NullReferenceException(nameof(fileSystem));
}
MethodInfo bindAll = null;
if (!isWorker)
{
if (listener == null)
{
throw new NullReferenceException(nameof(listener));
}
bindAll = typeof(Values).GetMethod("BindAll", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static);
if (bindAll == null)
{
throw new Exception("generate binding code before run");
}
var codeGenVersionField = typeof(Values).GetField("CodeGenVersion");
if (codeGenVersionField == null || !codeGenVersionField.IsStatic || !codeGenVersionField.IsLiteral || codeGenVersionField.FieldType != typeof(uint))
{
throw new Exception("binding code version mismatch");
}
var codeGenVersion = (uint)codeGenVersionField.GetValue(null);
if (codeGenVersion != ScriptEngine.VERSION)
{
if (logger != null)
{
logger.Write(LogLevel.Warn, "CodeGenVersion: {0} != {1}", codeGenVersion, ScriptEngine.VERSION);
}
}
}
asyncManager.Initialize(_mainThreadId);
_isValid = true;
_isRunning = true;
// _rwlock = new ReaderWriterLockSlim();
_rt = JSApi.JS_NewRuntime();
JSApi.JS_SetHostPromiseRejectionTracker(_rt, JSApi.PromiseRejectionTracker, IntPtr.Zero);
#if UNITY_EDITOR
JSApi.JS_SetInterruptHandler(_rt, _InterruptHandler, IntPtr.Zero);
#else
if (isWorker)
{
JSApi.JS_SetInterruptHandler(_rt, _InterruptHandler, IntPtr.Zero);
}
#endif
JSApi.JS_SetRuntimeOpaque(_rt, (IntPtr)_runtimeId);
JSApi.JS_SetModuleLoaderFunc(_rt, module_normalize, module_loader, IntPtr.Zero);
CreateContext();
JSApi.JS_NewClass(_rt, JSApi.JSB_GetBridgeClassID(), "CSharpClass", JSApi.class_finalizer);
_listener = listener;
_pathResolver = resolver;
_asyncManager = asyncManager;
_byteBufferAllocator = byteBufferAllocator;
_autorelease = new Utils.AutoReleasePool();
_fileSystem = fileSystem;
_logger = logger;
_objectCache = new ObjectCache(_logger);
_timerManager = new TimerManager(_logger);
_typeDB = new TypeDB(this, _mainContext);
_typeDB.AddType(typeof(Unity.JSBehaviour), JSApi.JS_UNDEFINED);
#if UNITY_EDITOR
_typeDB.AddType(typeof(Unity.JSEditorWindow), JSApi.JS_UNDEFINED);
_typeDB.AddType(typeof(Unity.JSBehaviourInspector), JSApi.JS_UNDEFINED);
#endif
listener.OnCreate(this);
// await Task.Run(() => runner.OnBind(this, register));
if (bindAll != null)
{
bindAll.Invoke(null, new object[] { this });
}
var register = new TypeRegister(_mainContext);
listener.OnBind(this, register);
if (!_isWorker)
{
JSWorker.Bind(register);
}
TimerManager.Bind(register);
register.Finish();
AddStaticModule("jsb", ScriptContext.Bind);
FindModuleResolver <StaticModuleResolver>().Warmup(_mainContext);
listener.OnComplete(this);
}
public PathResolverTestFixture(IPathResolver pathResolver)
{
this.PathResolver = pathResolver;
}
public SolutionParser(IPathResolver pathResolver)
{
_pathResolver = pathResolver;
}
public OnDemandAssetLoadStrategy(IPathResolver w3dPathResolver, IPathResolver texturePathResolver)
: this(true)
{
_w3dPathResolver = w3dPathResolver;
_texturePathResolver = texturePathResolver;
}
public FileSystemService(IPathResolver pathResolver, ITrace trace)
{
PathResolver = pathResolver;
Trace = trace;
}
/// <summary>
/// Migrates preference settings and copies packages and custom node
/// definitions from the last but one version to the currently installed Dynamo version
/// </summary>
/// <param name="pathManager"></param>
/// <param name="pathResolver"></param>
/// <returns>new migrator instance after migration</returns>
public static DynamoMigratorBase MigrateBetweenDynamoVersions(IPathManager pathManager, IPathResolver pathResolver)
{
var userDataDir = Path.GetDirectoryName(pathManager.UserDataDirectory);
var versions = GetInstalledVersions(userDataDir).ToList();
if (versions.Count() < 2)
{
return(null); // No need for migration
}
var previousVersion = versions[1];
var currentVersion = versions[0];
return(Migrate(pathResolver, previousVersion, currentVersion));
}
public VirtualPathFileReader()
{
var config = AssmanConfiguration.Current;
_pathResolver = VirtualPathResolver.GetInstance(config.RootFilePath);
}
public ElementEditor(Stylesheet stylesheet, IPathResolver resolver)
{
_stylesheet = stylesheet;
_resolver = resolver;
}
public bool ContainsModule(IFileSystem fileSystem, IPathResolver pathResolver, string resolved_id)
{
return(_modRegisters.ContainsKey(resolved_id));
}
public void Configure(string cahcheFolder, IPathResolver pathResolver)
{
_cahcheFolder = cahcheFolder;
_pathResolver = pathResolver;
}
internal CalculateComponentGuids(IMessaging messaging, IBackendHelper helper, IPathResolver pathResolver, IntermediateSection section, Platform platform)
{
this.Messaging = messaging;
this.BackendHelper = helper;
this.PathResolver = pathResolver;
this.Section = section;
this.Platform = platform;
}
public FileReader(IPathResolver pathResolver)
{
PathResolver = pathResolver;
}
public MapDataLibrary(IPathResolver pathResolver, ITrace trace)
{
_pathResolver = pathResolver;
_trace = trace;
}
public SiteManager(IPathResolver pathResolver, bool traceFailedRequests, string logPath)
{
_logPath = logPath;
_pathResolver = pathResolver;
_traceFailedRequests = traceFailedRequests;
}
static Interop()
{
IPathResolver pathResolver = null;
IPlatformLoader loader = null;
if (Host.GetExportedSymbol != null)
{
// We are loading exported functions from the currently running executable.
pathResolver = new Host.Loader();
loader = new Host.Loader();
}
else
{
pathResolver = new DynamicLinkLibraryPathResolver();
loader = PlatformLoaderBase.SelectPlatformLoader();
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// This custom path resolver attempts to do a DllImport to get the path that .NET decides.
// It may load a special dll from a NuGet package.
pathResolver = new WindowsDllImportLibraryPathResolver(pathResolver);
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
pathResolver = new MacDllImportLibraryPathResolver(pathResolver);
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
pathResolver = new LinuxDllImportLibraryPathResolver(pathResolver);
}
}
var result = pathResolver.Resolve("QmlNet");
if (!result.IsSuccess)
{
throw new Exception("Couldn't find the native Qml.Net library.");
}
var library = loader.LoadLibrary(result.Path);
Callbacks = LoadInteropType <CallbacksInterop>(library, loader);
NetTypeInfo = LoadInteropType <NetTypeInfoInterop>(library, loader);
NetJsValue = LoadInteropType <NetJsValueInterop>(library, loader);
NetMethodInfo = LoadInteropType <NetMethodInfoInterop>(library, loader);
NetPropertyInfo = LoadInteropType <NetPropertyInfoInterop>(library, loader);
NetTypeManager = LoadInteropType <NetTypeManagerInterop>(library, loader);
QCoreApplication = LoadInteropType <QCoreApplicationInterop>(library, loader);
QQmlApplicationEngine = LoadInteropType <QQmlApplicationEngineInterop>(library, loader);
NetVariant = LoadInteropType <NetVariantInterop>(library, loader);
NetReference = LoadInteropType <NetReferenceInterop>(library, loader);
NetVariantList = LoadInteropType <NetVariantListInterop>(library, loader);
NetTestHelper = LoadInteropType <NetTestHelperInterop>(library, loader);
NetSignalInfo = LoadInteropType <NetSignalInfoInterop>(library, loader);
QResource = LoadInteropType <QResourceInterop>(library, loader);
NetDelegate = LoadInteropType <NetDelegateInterop>(library, loader);
QQuickStyle = LoadInteropType <QQuickStyleInterop>(library, loader);
QtInterop = LoadInteropType <QtInterop>(library, loader);
Utilities = LoadInteropType <UtilitiesInterop>(library, loader);
QtWebEngine = LoadInteropType <QtWebEngineInterop>(library, loader);
QTest = LoadInteropType <QTestInterop>(library, loader);
// RuntimeManager.ConfigureRuntimeDirectory may set these environment variables.
// However, they only really work when called with Qt.PutEnv.
Qt.PutEnv("QT_PLUGIN_PATH", Environment.GetEnvironmentVariable("QT_PLUGIN_PATH"));
Qt.PutEnv("QML2_IMPORT_PATH", Environment.GetEnvironmentVariable("QML2_IMPORT_PATH"));
var cb = DefaultCallbacks.Callbacks();
Callbacks.RegisterCallbacks(ref cb);
}
public FrontendController(IEnumerable <Meta <IPathResolver> > resolvers)
{
_rootResolver = resolvers.First(x => (WellKnownDirectory)x.Metadata[nameof(WellKnownDirectory)] == WellKnownDirectory.WebDeployment).Value;
}
public MapDataLoader(IMapDataProvider mapDataProvider, IPathResolver pathResolver)
{
_mapDataProvider = mapDataProvider;
_pathResolver = pathResolver;
}
