public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
log.Trace("Determining subscriptions for node " + _cache.NodeName);
_repository.SaveTransportNode();
var requirements = determineStaticRequirements(log);
if (requirements.Any())
{
log.Trace("Found static subscription requirements:");
requirements.Each(x => log.Trace(x.ToString()));
}
else
{
log.Trace("No static subscriptions found from registry");
}
_repository.PersistSubscriptions(requirements);
var subscriptions = _repository.LoadSubscriptions(SubscriptionRole.Publishes);
_cache.LoadSubscriptions(subscriptions);
sendSubscriptions();
}
public void Activate(IEnumerable <IPackageInfo> packages, IPackageLog log)
{
log.Trace("Determining subscriptions for node " + _cache.NodeName);
// assuming that there are no automaticly persistent tasks
// upon startup
_repository.Persist(new TransportNode(_graph));
var requirements = determineStaticRequirements(log);
if (requirements.Any())
{
log.Trace("Found static subscription requirements:");
requirements.Each(x => log.Trace(x.ToString()));
}
else
{
log.Trace("No static subscriptions found from registry");
}
_repository.PersistSubscriptions(requirements);
var subscriptions = _repository.LoadSubscriptions(SubscriptionRole.Publishes);
_cache.LoadSubscriptions(subscriptions);
sendSubscriptions();
}
public IEnumerable <IPackageInfo> Load(IPackageLog log)
{
var packages = new List <IPackageInfo>();
var manifestFile = FileSystem.Combine(_applicationDirectory, LinkManifest.FILE);
var manifest = _fileSystem.LoadFromFile <LinkManifest>(manifestFile);
if (manifest == null)
{
log.Trace("No package manifest found at {0}", manifestFile);
return(packages);
}
if (manifest.LinkedFolders.Any())
{
log.Trace("Loading linked folders via the package manifest at " + _applicationDirectory);
manifest.LinkedFolders.Each(folder =>
{
var linkedFolder = FileSystem.Combine(_applicationDirectory, folder).ToFullPath();
log.Trace(" - linking folder " + linkedFolder);
var package = _reader.LoadFromFolder(linkedFolder);
packages.Add(package);
});
}
else
{
log.Trace("No linked folders found in the package manifest file at " + _applicationDirectory);
}
return(packages);
}
public IEnumerable<IPackageInfo> Load(IPackageLog log)
{
var packages = new List<IPackageInfo>();
var manifestFile = _applicationDirectory.AppendPath(LinkManifest.FILE);
var manifest = _fileSystem.LoadFromFile<LinkManifest>(manifestFile);
if (manifest == null)
{
log.Trace("No package manifest found at {0}", manifestFile);
return packages;
}
if (manifest.LinkedFolders.Any())
{
log.Trace("Loading linked folders via the package manifest at " + _applicationDirectory);
manifest.LinkedFolders.Each(folder =>
{
if (Platform.IsUnix()) {
folder = folder.Replace('\\', Path.DirectorySeparatorChar);
}
var linkedFolder = FileSystem.Combine(_applicationDirectory, folder).ToFullPath();
log.Trace(" - linking folder " + linkedFolder);
var package = _reader.LoadFromFolder(linkedFolder);
packages.Add(package);
});
}
else
{
log.Trace("No linked folders found in the package manifest file at " + _applicationDirectory);
}
return packages;
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
log.Trace("Determining subscriptions for node " + _cache.NodeName);
// assuming that there are no automaticly persistent tasks
// upon startup
_repository.Persist(new TransportNode(_graph));
var requirements = determineStaticRequirements(log);
if (requirements.Any())
{
log.Trace("Found static subscription requirements:");
requirements.Each(x => log.Trace(x.ToString()));
}
else
{
log.Trace("No static subscriptions found from registry");
}
_repository.PersistSubscriptions(requirements);
var subscriptions = _repository.LoadSubscriptions(SubscriptionRole.Publishes);
_cache.LoadSubscriptions(subscriptions);
sendSubscriptions();
}
private void configureRazorSettings(IPackageLog log)
{
_engine.Namespaces.Add(typeof(VirtualPathUtility).Namespace); // System.Web
_engine.Namespaces.Add(typeof(RazorViewFacility).Namespace); // FubuMVC.Razor
_engine.Namespaces.Add(typeof(FubuPageExtensions).Namespace); // FubuMVC.Core.UI
_engine.Namespaces.Add(typeof(HtmlTag).Namespace); // HtmlTags
log.Trace("Adding namespaces to RazorSettings:");
_engine.Namespaces.Each(x => log.Trace(" - {0}".ToFormat(x)));
}
private void configureRazorSettings(IPackageLog log)
{
_engine.Namespaces.Add(typeof(VirtualPathUtility).Namespace); // System.Web
_engine.Namespaces.Add(typeof(RazorViewFacility).Namespace); // FubuMVC.Razor
_engine.Namespaces.Add(typeof(FubuPageExtensions).Namespace); // FubuMVC.Core.UI
_engine.Namespaces.Add(typeof(HtmlTag).Namespace); // HtmlTags
log.Trace("Adding namespaces to RazorSettings:");
_engine.Namespaces.Each(x => log.Trace(" - {0}".ToFormat(x)));
}
private void configureRazorSettings(IPackageLog log)
{
_namespaces.Add(typeof(VirtualPathUtility).Namespace); // System.Web)
_namespaces.AddForType<RazorViewFacility>(); // FubuMVC.Razor
_namespaces.AddForType<IPartialInvoker>(); // FubuMVC.Core.UI
_namespaces.AddForType<HtmlTag>(); // HtmlTags
_namespaces.AddForType<string>();
log.Trace("Adding namespaces to RazorSettings:");
_namespaces.Namespaces.Each(x => log.Trace(" - {0}".ToFormat(x)));
}
void IFubuRegistryExtension.Configure(FubuRegistry registry)
{
if (shouldScan())
{
scan(registry);
}
_logger.Trace("Adding [{0}] to registry [{1}]", typeof(SparkViewFacility).Name, registry.Name);
registry.Views.Facility(new SparkViewFacility(_templateRegistry));
registry.Services(configureServices);
}
private void setEngineDependencies(IPackageLog log)
{
var engine = (SparkViewEngine) _engine;
engine.ViewFolder = new TemplateViewFolder(_templateRegistry);
log.Trace("Setting viewfolder [{0}] for view engine", _engine.ViewFolder.GetType().FullName);
engine.DefaultPageBaseType = typeof(FubuSparkView).FullName;
log.Trace("Setting page base type [{0}] for views", _engine.DefaultPageBaseType);
engine.BindingProvider = new FubuBindingProvider(_templateRegistry);
log.Trace("Setting binding provider [{0}] for view engine", engine.BindingProvider.GetType().FullName);
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
if (!_settings.AutoHostingEnabled)
{
log.Trace("Embedded Katana hosting is not enabled");
return;
}
Console.WriteLine("Starting Katana hosting at port " + _settings.Port);
log.Trace("Starting Katana hosting at port " + _settings.Port);
_settings.EmbeddedServer = new EmbeddedFubuMvcServer(_settings, _urls, _services, _routes);
}
public void Activate(IEnumerable <IPackageInfo> packages, IPackageLog log)
{
if (!_settings.AutoHostingEnabled)
{
log.Trace("Embedded Katana hosting is not enabled");
return;
}
Console.WriteLine("Starting Katana hosting at port " + _settings.Port);
log.Trace("Starting Katana hosting at port " + _settings.Port);
_settings.EmbeddedServer = new EmbeddedFubuMvcServer(_runtime, port: _settings.Port);
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
if (!_settings.AutoHostingEnabled)
{
log.Trace("Embedded Nowin hosting is not enabled");
return;
}
Console.WriteLine("Starting Nowin hosting at port " + _settings.Port);
log.Trace("Starting Nowin hosting at port " + _settings.Port);
_settings.EmbeddedServer = new EmbeddedFubuMvcServer(_runtime, port:_settings.Port);
}
private void setEngineDependencies(IPackageLog log)
{
var engine = (SparkViewEngine)_engine;
engine.ViewFolder = new TemplateViewFolder(_templateRegistry);
log.Trace("Setting viewfolder [{0}] for view engine", _engine.ViewFolder.GetType().FullName);
engine.DefaultPageBaseType = typeof(FubuSparkView).FullName;
log.Trace("Setting page base type [{0}] for views", _engine.DefaultPageBaseType);
engine.BindingProvider = new FubuBindingProvider(_templateRegistry);
log.Trace("Setting binding provider [{0}] for view engine", engine.BindingProvider.GetType().FullName);
}
// TODO -- gotta put some serious logging here when we get to diagnostics
// and package loading
public void LoadFiles(PackageAssetDirectory directory)
{
var contentFolder = FindContentFolder(directory.Directory);
if (contentFolder == null)
{
string theMessage = NoContentFoundForPackageAt.ToFormat(directory.Directory);
_log.Trace(theMessage);
return;
}
_log.Trace(LoadingContentForPackageAt.ToFormat(contentFolder));
LoadFilesFromContentFolder(directory, contentFolder);
}
public void Deactivate(IPackageLog log)
{
if(_settings.Disabled) return;
log.Trace("Shutting down the scheduled jobs");
_scheduledJobs.Deactivate();
}
public static IEnumerable <T> VerifyAnyRegistrations <T>(this IServiceLocator services, IPackageLog log)
{
try
{
var holder = services.GetInstance <Holder <T> >();
holder.List.Each(x => {
log.Trace("Using {0} for {1}", x.GetType().FullName, typeof(T).FullName);
});
if (!holder.List.Any())
{
log.MarkFailure("No implementations of {0} are registered", typeof(T).FullName);
}
return(holder.List);
}
catch (Exception ex)
{
log.MarkFailure("Could not resolve the list of " + typeof(T).FullName);
log.MarkFailure(ex);
return(Enumerable.Empty <T>());
}
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
var postActionsFinder = new BehaviorVisitor(_graph.Observer, "Looking for valid POST actions.");
postActionsFinder.Filters.Add(x => x.Route != null);
postActionsFinder.Filters.Add(x => x.Route.AllowedHttpMethods.Contains("POST"));
postActionsFinder.Filters.Add(x => x.FirstCall() != null);
postActionsFinder.Filters.Add(x => x.FirstCall().HasOutput);
postActionsFinder.Filters.Add(x => x.FirstCall().HasInput);
postActionsFinder.Actions += x =>
{
var postAction = x.FirstCall();
var handlerActions = _graph.ActionsForHandler(postAction.HandlerType);
var getAction = handlerActions
.Where(h => h.ParentChain().Route != null)
.Where(h => h.ParentChain().Route.AllowedHttpMethods.Contains("GET"))
.Where(h => h.HasInput).Where(h => h.HasOutput)
.FirstOrDefault(h => x.InputType().IsAssignableFrom(h.OutputType()));
if (getAction == null)
{
return;
}
log.Trace("Linking validation descriptor for {0} against {1}.", postAction, getAction);
_provider.Register(postAction, getAction.InputType());
};
_graph.VisitBehaviors(postActionsFinder);
}
public void Activate(IEnumerable <IPackageInfo> packages, IPackageLog log)
{
log.Trace("Running {0}".ToFormat(GetType().Name));
configureSparkSettings(log);
setEngineDependencies(log);
}
public IEnumerable<IPackageInfo> Load(IPackageLog log)
{
var list = new List<string> { AppDomain.CurrentDomain.SetupInformation.ApplicationBase };
string binPath = AppDomain.CurrentDomain.SetupInformation.PrivateBinPath;
if (binPath.IsNotEmpty())
{
if (Path.IsPathRooted(binPath))
{
list.Add(binPath);
}
else
{
list.Add(AppDomain.CurrentDomain.SetupInformation.ApplicationBase.AppendPath(binPath));
}
}
list.Each(x =>
{
log.Trace("Looking for assemblies marked with the [FubuModule] attribute in " + x);
});
return list.SelectMany(
x =>
AssembliesFromPath(x, assem => assem.GetCustomAttributes(typeof (FubuModuleAttribute), false).Any()))
.Select(assem => new AssemblyPackageInfo(assem));
}
// I would rather have this as a ISharingPolicy, but don't know how to ensure it is applied last.
public void RegisterAppGlobal(IPackageLog log)
{
log.Trace("Registering application as global sharing.");
Diagnostics.SetCurrentProvenance(TemplateConstants.HostOrigin);
Diagnostics.Global(TemplateConstants.HostOrigin);
}
public IEnumerable <IPackageInfo> Load(IPackageLog log)
{
var list = new List <string> {
AppDomain.CurrentDomain.SetupInformation.ApplicationBase
};
string binPath = AppDomain.CurrentDomain.SetupInformation.PrivateBinPath;
if (binPath.IsNotEmpty())
{
if (Path.IsPathRooted(binPath))
{
list.Add(binPath);
}
else
{
list.Add(AppDomain.CurrentDomain.SetupInformation.ApplicationBase.AppendPath(binPath));
}
}
list.Each(x =>
{
log.Trace("Looking for assemblies marked with the [FubuModule] attribute in " + x);
});
return(list.SelectMany(
x =>
AssembliesFromPath(x, assem => assem.GetCustomAttributes(typeof(FubuModuleAttribute), false).Any()))
.Select(assem => new AssemblyPackageInfo(assem)));
}
public IEnumerable <IPackageInfo> Load(IPackageLog log)
{
var list = new List <string> {
AppDomain.CurrentDomain.SetupInformation.ApplicationBase
};
var binPath = FubuMvcPackageFacility.FindBinPath();
if (binPath.IsNotEmpty())
{
list.Add(binPath);
}
// This is a workaround for Self Hosted apps where the physical path is different than the AppDomain's original
// path
if (FubuMvcPackageFacility.PhysicalRootPath.IsNotEmpty())
{
var path = FubuMvcPackageFacility.PhysicalRootPath.ToFullPath().AppendPath("bin");
if (Directory.Exists(path) && !list.Select(x => x.ToLower()).Contains(path.ToLower()))
{
list.Add(path);
}
}
list.Each(x =>
{
log.Trace("Looking for assemblies marked with the [FubuModule] attribute in " + x);
});
return(LoadPackages(list));
}
public void ReadScriptConfig(string folder, IPackageLog log)
{
log.Trace("Trying to read *script.config / *asset.config files from {0}", folder);
var files = _fileSystem.FindFiles(folder, new FileSet(){
Include = "*.script.config;*.asset.config",
DeepSearch = false
});
if (!files.Any())
{
log.Trace(" No *.script.config or *.asset.config files found");
return;
}
files.Each(file => ReadFile(file, log));
}
// I would rather have this as a ISharingPolicy, but don't know how to ensure it is applied last.
public void RegisterAppGlobal(IPackageLog log)
{
log.Trace("Registering application as global sharing.");
Diagnostics.SetCurrentProvenance(TemplateConstants.HostOrigin);
Diagnostics.Global(TemplateConstants.HostOrigin);
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
log.Trace("Running {0}".ToFormat(GetType().Name));
configureSparkSettings(log);
setEngineDependencies(log);
}
public void Activate(IEnumerable <IPackageInfo> packages, IPackageLog log)
{
var postActionsFinder = new BehaviorVisitor(_graph.Observer, "Looking for valid POST actions.");
postActionsFinder.Filters.Add(x => x.Route != null);
postActionsFinder.Filters.Add(x => x.Route.AllowedHttpMethods.Contains("POST"));
postActionsFinder.Filters.Add(x => x.FirstCall() != null);
postActionsFinder.Filters.Add(x => x.FirstCall().HasOutput);
postActionsFinder.Filters.Add(x => x.FirstCall().HasInput);
postActionsFinder.Actions += x =>
{
var postAction = x.FirstCall();
var handlerActions = _graph.ActionsForHandler(postAction.HandlerType);
var getAction = handlerActions
.Where(h => h.ParentChain().Route != null)
.Where(h => h.ParentChain().Route.AllowedHttpMethods.Contains("GET"))
.Where(h => h.HasInput).Where(h => h.HasOutput)
.FirstOrDefault(h => x.InputType().IsAssignableFrom(h.OutputType()));
if (getAction == null)
{
return;
}
log.Trace("Linking validation descriptor for {0} against {1}.", postAction, getAction);
_provider.Register(postAction, getAction.InputType());
};
_graph.VisitBehaviors(postActionsFinder);
}
public void CompileDependencies(IEnumerable <IPackageInfo> packages, IPackageLog log)
{
var provenances = packages.Select(p => p.Name).Union(new[] { TemplateConstants.HostOrigin }).ToArray();
log.Trace("Compiling dependencies for [{0}]", provenances.Join(", "));
_graph.CompileDependencies(provenances);
}
public IEnumerable <IPackageInfo> Load(IPackageLog log)
{
return(_contentFolders.Select(x =>
{
log.Trace("Loading content package from " + x);
return new ContentOnlyPackageInfo(x, Path.GetFileName(x));
}));
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
_policies.Each(p =>
{
log.Trace("Running " + p);
p.Apply(log, _fileGraph, _graph);
});
}
// TODO -- harden with a better exception
public Type FindEnvironmentType(IPackageLog log)
{
if (EnvironmentClassName.IsNotEmpty())
{
log.Trace("Environment class was specified '{0}'", EnvironmentClassName);
return Type.GetType(EnvironmentClassName);
}
log.Trace("Scanning AppDomain for IEnvironment");
var foundClass = AppDomain.CurrentDomain
.Load(AssemblyName)
.GetExportedTypes()
.First(x => x.IsConcreteTypeOf<IEnvironment>());
log.Trace("Found Environment class '{0}'", foundClass);
return foundClass;
}
public IEnumerable<IPackageInfo> Load(IPackageLog log)
{
Func<Assembly, bool> filter = assem => assem.GetCustomAttributes(typeof(BottleServiceAttribute), false).Any();
Action<string> onDirectoryFound = dir => log.Trace("Looking for assemblies marked with the [BottleService] attribute in " + dir);
var assemblies = AssemblyFinder.FindAssemblies(filter, onDirectoryFound);
return assemblies.Select(x => new AssemblyPackageInfo(x));
}
public void ReadScriptConfig(string folder, IPackageLog log)
{
log.Trace("Trying to read *script.config / *asset.config files from {0}", folder);
var files = _fileSystem.FindFiles(folder, new FileSet
{
Include = "*.script.config;*.asset.config",
DeepSearch = true
});
if (!files.Any())
{
log.Trace(" No *.script.config or *.asset.config files found");
return;
}
files.Where(x => !x.PathRelativeTo(folder).Contains(FubuMvcPackageFacility.FubuContentFolder)).Each(file => ReadFile(file, log));
}
public IEnumerable<IPackageInfo> Load(IPackageLog log)
{
return _contentFolders.Select(x =>
{
log.Trace("Loading content package from " + x);
return new ContentOnlyPackageInfo(x, Path.GetFileName(x));
});
}
public IEnumerable <IPackageInfo> Load(IPackageLog log)
{
Func <Assembly, bool> filter = assem => assem.GetCustomAttributes(typeof(BottleServiceAttribute), false).Any();
Action <string> onDirectoryFound = dir => log.Trace("Looking for assemblies marked with the [BottleService] attribute in " + dir);
var assemblies = AssemblyFinder.FindAssemblies(filter, onDirectoryFound);
return(assemblies.Select(x => new AssemblyPackageInfo(x)));
}
public void CompileDependencies(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
var provenances = packages.Select(p => p.Name).Union(new[] { TemplateConstants.HostOrigin }).ToArray();
log.Trace("Compiling dependencies for [{0}]", provenances.Join(", "));
_graph.CompileDependencies(provenances);
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
_registries.Each(r =>
{
log.Trace("Adding " + r);
r.Configure(_stringifier);
});
}
public IEnumerable<IInstaller> StartUp(IPackageLog log)
{
log.Trace("I started up with all good installers");
yield return new GoodInstaller1();
yield return new GoodInstaller2();
yield return new GoodInstaller3();
}
public void Activate(IEnumerable <IPackageInfo> packages, IPackageLog log)
{
_policies.Each(p =>
{
log.Trace("Running " + p);
p.Apply(log, _pipeline, _graph);
});
}
public void ReadSparkConfig(string provenance, string folder, IPackageLog log)
{
log.Trace("Looking for *spark.config in {0}", folder);
var configs = _fileSystem.FindFiles(folder, new FileSet
{
Include = "*spark.config;spark.config",
DeepSearch = false
});
if (!configs.Any())
{
log.Trace(" No *spark.config files found");
return;
}
configs.Each(file => ReadFile(provenance, file, log));
}
// TODO -- harden with a better exception
public Type FindEnvironmentType(IPackageLog log)
{
if (EnvironmentClassName.IsNotEmpty())
{
log.Trace("Environment class was specified '{0}'", EnvironmentClassName);
return(Type.GetType(EnvironmentClassName));
}
log.Trace("Scanning AppDomain for IEnvironment");
var foundClass = AppDomain.CurrentDomain
.Load(AssemblyName)
.GetExportedTypes()
.First(x => x.IsConcreteTypeOf <IEnvironment>());
log.Trace("Found Environment class '{0}'", foundClass);
return(foundClass);
}
public void Execute(FubuWebsite directive, HostManifest host, IPackageLog log)
{
if (_settings.UserForced)
{
log.Trace("UserForced: deleting directories");
_fileSystem.DeleteDirectory(directive.WebsitePhysicalPath);
_fileSystem.DeleteDirectory(directive.VDirPhysicalPath);
}
_fileSystem.CreateDirectory(directive.WebsitePhysicalPath);
_fileSystem.CreateDirectory(directive.VDirPhysicalPath);
var appOfflineFile = FileSystem.Combine(directive.VDirPhysicalPath, "app_offline.htm");
log.Trace("Applying the application offline file");
_fileSystem.WriteStringToFile(appOfflineFile, "<html><body>Application is being rebuilt</body></html>");
}
public void Activate(IEnumerable <IPackageInfo> packages, IPackageLog log)
{
_registries.Each(r =>
{
log.Trace("Adding " + r);
r.Configure(_stringifier);
});
}
public void ReadScriptConfig(string folder, IPackageLog log)
{
log.Trace("Trying to read *script.config / *asset.config files from {0}", folder);
var files = _fileSystem.FindFiles(folder, new FileSet
{
Include = "*.script.config;*.asset.config",
DeepSearch = true
});
if (!files.Any())
{
log.Trace(" No *.script.config or *.asset.config files found");
return;
}
files.Each(file => ReadFile(file, log));
}
private void applyFubuExtensionsFromPackages(IPackageLog log)
{
FubuExtensionFinder.FindAllExtensions().Each(x1 =>
{
log.Trace("Applying extension {0}", x1.GetType().FullName);
x1.Configure(_registry.Value);
});
}
public void ReadSparkConfig(string provenance, string folder, IPackageLog log)
{
log.Trace("Looking for *spark.config in {0}", folder);
var configs = _fileSystem.FindFiles(folder, new FileSet
{
Include = "*spark.config;spark.config",
DeepSearch = false
});
if (!configs.Any())
{
log.Trace(" No *spark.config files found");
return;
}
configs.Each(file => ReadFile(provenance, file, log));
}
public void Deactivate(IPackageLog log)
{
if (_settings.EmbeddedServer != null)
{
Console.WriteLine("Shutting down the embedded Katana server");
log.Trace("Shutting down the embedded Katana server");
_settings.EmbeddedServer.Dispose();
}
}
public void Activate(IEnumerable <IPackageInfo> packages, IPackageLog log)
{
_policies.Each(p =>
{
log.Trace("Running " + p);
p.Apply(log, _fileGraph, _graph);
});
_graph.PolicyTypes.Each(type =>
{
if (type.CanBeCastTo <IAssetPolicy>() && type.IsConcreteWithDefaultCtor())
{
var policy = Activator.CreateInstance(type).As <IAssetPolicy>();
log.Trace("Running " + policy);
policy.Apply(log, _fileGraph, _graph);
}
});
}
public void Deactivate(IPackageLog log)
{
if (_settings.EmbeddedServer != null)
{
Console.WriteLine("Shutting down the embedded Katana server");
log.Trace("Shutting down the embedded Katana server");
_settings.EmbeddedServer.Dispose();
}
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
_policies.Each(p =>
{
log.Trace("Running " + p);
p.Apply(log, _fileGraph, _graph);
});
_graph.PolicyTypes.Each(type =>
{
if (type.CanBeCastTo<IAssetPolicy>() && type.IsConcreteWithDefaultCtor())
{
var policy = Activator.CreateInstance(type).As<IAssetPolicy>();
log.Trace("Running " + policy);
policy.Apply(log, _fileGraph, _graph);
}
});
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
packages.Each(p => p.ForFolder(FubuMvcPackages.WebContentFolder, topFolder =>
{
var contentFolder = FileSystem.Combine(topFolder, "content");
log.Trace("Added folder '{0}' to the package folder list", contentFolder);
_contents.RegisterDirectory(contentFolder);
}));
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
packages.Each(p => p.ForFolder(FubuMvcPackages.WebContentFolder, topFolder =>
{
var imagesFolder = Path.Combine(topFolder, "content\\images");
log.Trace("Added folder '{0}' to the PackagedImageUrl list", imagesFolder);
_resolver.RegisterDirectory(imagesFolder);
}));
}
// We need to get these settings from DSL and defaults
private void configureSparkSettings (IPackageLog log)
{
var settings = (SparkSettings)_engine.Settings;
settings.SetAutomaticEncoding(true);
settings.AddAssembly (typeof(HtmlTag).Assembly)
.AddAssembly (typeof(FubuPageExtensions).Assembly)
.AddNamespace (typeof(VirtualPathUtility).Namespace) // System.Web
.AddNamespace (typeof(FubuRegistryExtensions).Namespace) // FubuMVC.Spark
.AddNamespace (typeof(FubuPageExtensions).Namespace) // FubuMVC.Core.UI
.AddNamespace (typeof(HtmlTag).Namespace); // HtmlTags
log.Trace("Adding assemblies to SparkSettings:");
settings.UseAssemblies.Each(x => log.Trace(" - {0}".ToFormat(x)));
log.Trace("Adding namespaces to SparkSettings:");
settings.UseNamespaces.Each(x => log.Trace(" - {0}".ToFormat(x)));
}
private void configureSparkSettings(IPackageLog log)
{
var settings = (SparkSettings)_engine.Settings;
settings.SetAutomaticEncoding(true);
settings.AddAssembly(typeof(HtmlTag).Assembly)
.AddAssembly(typeof(FubuPageExtensions).Assembly)
.AddNamespace(typeof(VirtualPathUtility).Namespace) // System.Web
.AddNamespace(typeof(SparkViewFacility).Namespace) // FubuMVC.Spark
.AddNamespace(typeof(FubuPageExtensions).Namespace) // FubuMVC.Core.UI
.AddNamespace(typeof(HtmlTag).Namespace); // HtmlTags
log.Trace("Adding assemblies to SparkSettings:");
settings.UseAssemblies.Each(x => log.Trace(" - {0}".ToFormat(x)));
log.Trace("Adding namespaces to SparkSettings:");
settings.UseNamespaces.Each(x => log.Trace(" - {0}".ToFormat(x)));
}
public IEnumerable <IInstaller> StartUp(IPackageLog log)
{
log.Trace("I started up with all good installers");
yield return(new GoodInstaller1());
yield return(new GoodInstaller2());
yield return(new GoodInstaller3());
}
public void Activate(IEnumerable <IPackageInfo> packages, IPackageLog log)
{
packages.Each(p => p.ForFolder(BottleFiles.WebContentFolder, topFolder =>
{
var contentFolder = FileSystem.Combine(topFolder, "content");
log.Trace("Added folder '{0}' to the package folder list", contentFolder);
_contents.RegisterDirectory(contentFolder);
}));
}
public void Deactivate(IPackageLog log)
{
if (_settings.Disabled)
{
return;
}
log.Trace("Shutting down the scheduled jobs");
_scheduledJobs.Deactivate();
}
public void Check(IPackageLog log)
{
if (Directory.Exists(_folder))
{
log.Trace(SuccessMessage, _folder);
}
else
{
log.MarkFailure(FailureMessage, _folder);
}
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
log.Trace("Looking for *view.config files");
var configs = _files.FindFiles(new FileSet
{
Include = "*view.config;view.config",
DeepSearch = false
});
ReadConfigs(configs, log);
}
public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
{
packages.Each(pak =>
{
pak.ForFolder(BottleFiles.WebContentFolder, dir =>
{
log.Trace("Adding directory {0} to PackageFileCache", dir);
_files.AddDirectory(dir);
});
});
}
