Bottles by Jeremy D. Miller, Dru Sellers, et al.

<PackageReference Include="Bottles" Version="2.2.0.610" />

---

API Diff between 2.2.0.610 and 0.9.1.133

572 Additions 77 Removals

Bottles

• public class AliasService
  • public AliasService()
  • public AliasService(IFileSystem fileSystem)
  • public string GetFolderForAlias(string alias)
• public static class AssemblyFinder
  • public static IEnumerable<Assembly> AssembliesFromPath(string path, Func<Assembly, bool> assemblyFilter)
  • public static IEnumerable<Assembly> FindAssemblies(Func<Assembly, bool> filter, Action<string> onDirectoryFound = null)
  • public static IEnumerable<Assembly> FindAssemblies(IEnumerable<string> directories, Func<Assembly, bool> filter)
• public class AssemblyTarget
  • public Assembly Assembly { get; set; }
  • public string AssemblyName { get; set; }
  • public string FilePath { get; set; }
  • public AssemblyTarget()
  • public static AssemblyTarget FromAssembly(Assembly assembly)
  • public void Load(IAssemblyRegistration loader)
• public class BottleDependencyProcessor
  • public BottleDependencyProcessor(IEnumerable<IPackageInfo> packages)
  • public void LogMissingPackageDependencies(IBottlingDiagnostics diagnostics)
  • public IEnumerable<IPackageInfo> OrderedPackages()
• public static class BottleFiles
  • public static readonly string BottlesFolder
  • public static readonly FileSet ConfigFiles
  • public static readonly FileSet DataFiles
• public class BottleLoadingRecord
  • public DateTime Finished { get; set; }
  • public DateTime Started { get; }
  • public BottleLoadingRecord()
• public static class BottleLogDependencyExtensions
  • public static void LogMissingDependency(this IPackageLog log, string dependencyName)
• public class Dependency
• public class CompileTarget
  • public static readonly CompileTarget Debug
  • public static readonly CompileTarget Release
  • public CompileTarget Build(string value)
  • public bool Equals(CompileTarget other)
• public static class FileSystemExtensions
  • public static string FindBinaryDirectory(this IFileSystem fileSystem, string directory, CompileTargetEnum target)
  • public static bool LinkManifestExists(this IFileSystem fileSystem, string directory)
  • public static LinkManifest LoadLinkManifestFrom(this IFileSystem fileSystem, string folder)
  • public static string FindBinaryDirectory(this IFileSystem fileSystem, string directory, string target)
  • public static T LoadFromStream<T>(this IFileSystem system, Stream fileStream)
• public interface IDeactivator
  • void Deactivate(IPackageLog log)
• public interface IPackageFiles
  • void ForData(string searchPattern, Action<string, Stream> dataCallback)
  • bool GetFiles(string folderName, string searchPattern, Action<string, Stream> onFileCallback)
• public interface IPackageInfo
  • Dependency[] Dependencies { get; }
  • string Description { get; }
  • IPackageFiles Files { get; }
  • PackageManifest Manifest { get; }
  • void ForData(string searchPattern, Action<string, Stream> dataCallback)
  • void ForFiles(string directory, string searchPattern, Action<string, Stream> fileCallback)
  • IEnumerable<Dependency> GetDependencies()
  • void LoadAssemblies(IAssemblyRegistration loader)
  • void LoadAssemblies(IAssemblyRegistration loader)
• public interface ISimpleLogger
• public class LinkedFolderPackageLoader : IPackageLoader
• public class LinkManifest
• public class PackageDependencyProcessor
• public class PackageFiles : IPackageFiles
  • public void ForData(string searchPattern, Action<string, Stream> dataCallback)
  • public bool GetFiles(string folderName, string searchPattern, Action<string, Stream> onFileCallback)
• public class PackageInfo : IPackageInfo, DescribesItself
  • public class AssemblyTarget
  • public Dependency[] Dependencies { get; set; }
  • public Dependency[] Dependencies { get; set; }
  • public IPackageFiles Files { get; }
  • public PackageManifest Manifest { get; }
  • public PackageInfo(string name)
  • public void AddDependency(Dependency dependency)
  • public PackageInfo(PackageManifest manifest)
  • protected void AddAssembly(AssemblyTarget assemblyTarget)
  • protected void AddAssembly(Assembly assembly)
  • public void AddDependency(Dependency dependency)
  • public void Describe(Description description)
  • public void ForFiles(string directory, string searchPattern, Action<string, Stream> fileCallback)
  • public void ForFolder(string folderName, Action<string> onFound)
  • public void LoadAssemblies(IAssemblyRegistration loader)
  • public void RemoveAllAssemblies()
• public class PackageLoadingRecord
• public static class PackageLogDependencyExtensions
• public class PackageManifest
  • public string[] AllAssemblies { get; }
  • public FileSet ConfigFileSet { get; set; }
  • public FileSet DataFileSet { get; set; }
  • public Dependency[] Dependencies { get; set; }
  • public Dependency[] Dependencies { get; set; }
  • public string[] NativeAssemblies { get; set; }
  • public static PackageManifest DefaultModuleManifest()
• public class PackageManifestReader : IPackageManifestReader
• public static class PackageRegistry
  • public static PackagingDiagnostics Diagnostics { get; }
  • public static readonly Cache<string, string> Properties
  • public static IBottlingDiagnostics Diagnostics { get; }
  • public static IEnumerable<RemoteService> Remotes { get; }
• public class PackagingRuntimeGraph : IDisposable
  • public PackagingRuntimeGraph(IPackagingDiagnostics diagnostics, IAssemblyLoader assemblies, IList<IPackageInfo> packages)
  • public PackagingRuntimeGraph(IBottlingDiagnostics diagnostics, IAssemblyLoader assemblies, IList<IPackageInfo> packages)
  • public void Dispose()
  • public IEnumerable<IPackageInfo> FindAllPackages()
  • public IDisposable InProvenance(string provenance, Action<PackagingRuntimeGraph> action)
• public static class ProfileFiles
• public class SimpleLogger : ISimpleLogger
• public static class ProvenanceHelper
  • public static string GetProvenanceFromStack()
• public class SolutionDirectoryPackageLoader : IPackageLoader
• public class ZipFilePackageLoader : IPackageLoader, DescribesItself
  • public ZipFilePackageLoader(string explosionDirectory, IEnumerable<string> folders)
  • public static string GetContentFolderForPackage(string packageFolder)
  • public void Describe(Description description)
  • public IEnumerable<IPackageInfo> Load(IPackageLog log)

Bottles.Assemblies

• public class AssemblyFileFinder : IAssemblyFileFinder
• public class AssemblyFiles
• public class AssemblyLoader : IAssemblyLoader, IAssemblyRegistration
• public class AssemblyPackageInfo : IPackageInfo
• public class AssemblyPackageLoader : IPackageLoader
• public interface IAssemblyFileFinder
• public interface IAssemblyLoader
• public interface IAssemblyRegistration

Bottles.Commands

• public class AliasCommand : FubuCommand<AliasInput>
  • public static string AliasFolder(string folder)
• public class AssembliesCommand : FubuCommand<AssembliesInput>
• public enum AssembliesCommandMode
• public class AssembliesInput
• public class AssemblyPackageCommand : FubuCommand<AssemblyPackageInput>
  • public ZipFolderRequest BuildZipRequest(AssemblyPackageInput input, FileSet fileSearch)
• public class AssemblyPackageInput
  • public bool InitFlag { get; set; }
  • public bool PreviewFlag { get; set; }
  • public string FindCsProjFile()
• public class CreatePackageCommand : FubuCommand<CreatePackageInput>
• public class InitPakCommand : FubuCommand<InitPakInput>
• public class InitPakInput
• public class CreateBottleCommand : FubuCommand<CreateBottleInput>
  • public CreateBottleCommand()
  • public virtual bool CreatePackage(CreateBottleInput input, IFileSystem fileSystem)
  • public bool Execute(CreateBottleInput input, IFileSystem fileSystem)
  • public virtual void WritePackageManifestDoesNotExist(string packageFolder)
  • public virtual void WriteZipFileAlreadyExists(string zipFileName)
• public class CreateBottleInput
  • public bool ForceFlag { get; set; }
  • public string ManifestFileNameFlag { get; set; }
  • public string PackageFolder { get; set; }
  • public bool PdbFlag { get; set; }
  • public string TargetFlag { get; set; }
  • public string ZipFileFlag { get; set; }
  • public CreateBottleInput()
  • public string GetZipFileName(PackageManifest manifest)
• public class InitCommand : FubuCommand<InitInput>
  • public InitCommand()
  • public void Execute(InitInput input, IFileSystem fileSystem)
• public class InitInput
  • public string AliasFlag { get; set; }
  • public bool ForceFlag { get; set; }
  • public string Name { get; set; }
  • public bool NoWebContentFlag { get; set; }
  • public bool OpenFlag { get; set; }
  • public string Path { get; set; }
  • public string RoleFlag { get; set; }
  • public InitInput()
• public class LinkCommand : FubuCommand<LinkInput>
  • public static void ListCurrentLinks(string appFolder, LinkManifest manifest)
  • public void Execute(LinkInput input, IFileSystem fileSystem)
  • public static string GuessAssemblyNameForFolder(string bottleFolder, FileSystem system)
  • public void Execute(LinkInput input, ILinksService links)
• public class LinkInput
  • public string BootstrapperFlag { get; set; }
  • public string BottleFolder { get; set; }
  • public string PackageFolder { get; set; }
  • public string ConfigFileFlag { get; set; }
  • public bool RemoteFlag { get; set; }
• public class OpenManifestCommand : FubuCommand<OpenManifestInput>
  • public OpenManifestCommand()
• public class OpenManifestInput
  • public string BottleDirectory { get; set; }
  • public OpenManifestInput()

Bottles.Configuration

• public class AssertBottleConfiguration : IActivator
  • public AssertBottleConfiguration(string provenance, IEnumerable<IBottleConfigurationRule> rules)
  • public void Activate(IEnumerable<IPackageInfo> packages, IPackageLog log)
• public class BottleConfiguration
  • public IEnumerable<BottleConfigurationError> Errors { get; }
  • public IEnumerable<MissingService> MissingServices { get; }
  • public string Provenance { get; }
  • public BottleConfiguration(string provenance)
  • public bool IsValid()
  • public void RegisterError(BottleConfigurationError error)
  • public void RegisterMissingService<T>()
  • public void RegisterMissingService(Type type)
• public interface BottleConfigurationError
• public class BottleConfigurationException : Exception
  • public IEnumerable<BottleConfigurationError> Errors { get; }
  • public IEnumerable<MissingService> MissingPlugins { get; }
  • public string Provenance { get; }
  • public BottleConfigurationException(string provenance, IEnumerable<BottleConfigurationError> errors)
• public interface IBottleConfigurationRule
  • void Evaluate(BottleConfiguration configuration)
• public class MissingService : BottleConfigurationError
  • public Type ServiceType { get; }
  • public MissingService(Type serviceType)
  • public bool Equals(MissingService other)

Bottles.Creation

• public enum CompileTargetEnum
• public class CreatePackageInput
• public class PackageCreator
• public class PackageManifestWriter
• public class ZipPackageCreator
  • public ZipPackageCreator(IFileSystem fileSystem, IZipFileService zipFileService, IBottleLogger logger, IAssemblyFileFinder assemblyFinder)
  • public void AddConfigFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
  • public void AddContentFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
  • public void AddDataFiles(CreateBottleInput input, IZipFile zipFile, PackageManifest manifest)
  • public bool CreatePackage(CreateBottleInput input, PackageManifest manifest)
  • public Guid WriteVersion(IZipFile zipFile)

Bottles.Diagnostics

• public static class BottleLogExtensions
  • public static void Fail(this IPackageLog log, string format, object[] parameters)
  • public static void Header1(this IPackageLog log, string format, object[] parameters)
  • public static void Header2(this IPackageLog log, string format, object[] parameters)
  • public static void Highlight(this IPackageLog log, string format, object[] parameters)
  • public static void Indent(this IPackageLog log)
  • public static void Indent(this IPackageLog log, Action action)
  • public static T Indent<T>(this IPackageLog log, Func<T> action)
  • public static void PrintHorizontalLine(this IPackageLog log)
  • public static void Success(this IPackageLog log, string format, object[] parameters)
  • public static void Trace(this IPackageLog log, string format, object[] parameters)
  • public static void Unindent(this IPackageLog log)
  • public static void Write(this IPackageLog log, ConsoleColor color, string format, object[] parameters)
• public class BottleLogger : IBottleLogger
  • public BottleLogger(LoggingSession log)
  • public void WriteAssembliesNotFound(AssemblyFiles theAssemblyFiles, PackageManifest manifest, CreateBottleInput input, string binFolder)
• public class BottlingDiagnostics : IBottlingDiagnostics
  • public BottlingDiagnostics(LoggingSession log)
  • public static string GetTypeName(object target)
  • public void EachLog(Action<object, PackageLog> action)
  • public bool HasErrors()
  • public void LogAssembly(IPackageInfo package, Assembly assembly, string provenance)
  • public void LogAssemblyFailure(IPackageInfo package, string fileName, Exception exception)
  • public void LogBootstrapperRun(IBootstrapper bootstrapper, IEnumerable<IActivator> activators)
  • public void LogDuplicateAssembly(IPackageInfo package, string assemblyName)
  • public void LogExecution(object target, Action continuation)
  • public IPackageLog LogFor(object target)
  • public void LogObject(object target, string provenance)
  • public void LogPackage(IPackageInfo package, IPackageLoader loader)
  • public IEnumerable<LogSubject> LogsForSubjectType<T>()
• public interface IBottleLogger
  • void WriteAssembliesNotFound(AssemblyFiles theAssemblyFiles, PackageManifest manifest, CreateBottleInput theInput, string binFolder)
• public interface IBottlingDiagnostics
  • void EachLog(Action<object, PackageLog> action)
  • bool HasErrors()
  • void LogAssembly(IPackageInfo package, Assembly assembly, string provenance)
  • void LogAssemblyFailure(IPackageInfo package, string fileName, Exception exception)
  • void LogBootstrapperRun(IBootstrapper bootstrapper, IEnumerable<IActivator> activators)
  • void LogDuplicateAssembly(IPackageInfo package, string assemblyName)
  • void LogExecution(object target, Action continuation)
  • IPackageLog LogFor(object target)
  • void LogObject(object target, string provenance)
  • void LogPackage(IPackageInfo package, IPackageLoader loader)
  • IEnumerable<LogSubject> LogsForSubjectType<T>()
• public interface IPackageLog
  • void MarkFailure(string text)
  • void MarkFailure(string text, object[] parameters)
  • void TrapErrors(Action action)
• public static class IPackageLogExtensions
• public interface IPackageLogger
• public interface IPackagingDiagnostics
• public class LogEntry
• public class LoggingSession
  • public IEnumerable<LogSubject> LogsForSubjectType<T>()
• public static class LoggingSessionWriter
• public class LogSubject
  • public PackageLog Log { get; set; }
  • public object Subject { get; set; }
  • public LogSubject()
• public class PackageLog : IPackageLog
  • public void MarkFailure(string text)
  • public void MarkFailure(string text, object[] args)
  • public void TrapErrors(Action action)
• public static class PackageLogExtensions
• public class PackageLogger : IPackageLogger
• public class PackagingDiagnostics : LoggingSession, IPackagingDiagnostics
• public static class PackagingDiagnosticsExtensions
  • public static void LogExecutionOnEach<T>(this IPackagingDiagnostics diagnostics, IEnumerable<T> targets, Action<T> continuation)
  • public static void LogPackages(this IPackagingDiagnostics diagnostics, IPackageLoader loader, IEnumerable<IPackageInfo> packages)
  • public static void LogExecutionOnEach<TItem>(this IBottlingDiagnostics diagnostics, IEnumerable<TItem> targets, Action<TItem, IPackageLog> continuation)
  • public static void LogPackages(this IBottlingDiagnostics diagnostics, IPackageLoader loader, IEnumerable<IPackageInfo> packages)

Bottles.Environment

• public class EnvironmentGateway : IEnvironmentGateway
• public static class EnvironmentListExtensions
• public class EnvironmentProxy : MarshalByRefObject
• public class EnvironmentRun
• public class EnvironmentRunner
• public class EnvironmentRunnerException : Exception
• public interface IEnvironment : IDisposable
• public interface IEnvironmentGateway
• public interface IInstaller
• public class CanWriteToFolder : IEnvironmentRequirement
  • public string DescriptionMessage
  • public string FailureMessage
  • public string SuccessMessage
  • public string TracerFile
  • public CanWriteToFolder(string folder)
  • public void Check(IPackageLog log)
  • public string Describe()
• public class CanWriteToFolder<TSettings> : CanWriteToFolder
  • public CanWriteToFolder(TSettings settings, Expression<Func<TSettings, object>> property)
• public class FileExists : IEnvironmentRequirement
  • public string DescriptionMessage
  • public string FailureMessage
  • public string SuccessMessage
  • public FileExists(string file)
  • public void Check(IPackageLog log)
  • public string Describe()
• public class FileExists<TSettings> : FileExists
  • public FileExists(Expression<Func<TSettings, object>> property, TSettings settings)
• public class FolderExists : IEnvironmentRequirement
  • public string DescriptionMessage
  • public string FailureMessage
  • public string SuccessMessage
  • public FolderExists(string folder)
  • public void Check(IPackageLog log)
  • public string Describe()
• public class FolderExists<TSettings> : FolderExists
  • public FolderExists(Expression<Func<TSettings, object>> property, TSettings settings)
• public interface IEnvironmentRequirement
  • void Check(IPackageLog log)
  • string Describe()
• public interface IEnvironmentRequirements
  • IEnumerable<IEnvironmentRequirement> Requirements()

Bottles.Exceptions

• public class BottleException : Exception
  • public BottleException()
  • public BottleException(string message)
  • public BottleException(string message, Exception innerException)
  • protected BottleException(SerializationInfo info, StreamingContext context)

Bottles.Exploding

• public class BottleExploder : IBottleExploder
  • public class ExplodeRequest
  • public BottleExploder(IZipFileService service, IBottleExploderLogger logger, IFileSystem fileSystem)
  • public static BottleExploder GetPackageExploder(IFileSystem fileSystem)
  • public static BottleExploder GetPackageExploder(IPackageLog log)
  • public void CleanAll(string applicationDirectory)
  • public void Explode(string sourceZipFile, string destinationDirectory, ExplodeOptions options)
  • public IEnumerable<string> ExplodeAllZipsAndReturnPackageDirectories(string applicationDirectory, IPackageLog log)
  • public void ExplodeAssembly(string applicationDirectory, Assembly assembly, IPackageInfo packageInfo)
  • public IEnumerable<string> ExplodeDirectory(ExplodeDirectory directory)
  • public string ReadVersion(string directoryName)
• public class BottleExploderLogger : IBottleExploderLogger
  • public BottleExploderLogger(Action<string> writer)
  • public void WriteExistingDirectories(string applicationDirectory, IEnumerable<string> existingDirectories)
  • public void WritePackageDirectoryDeleted(string directoryName)
  • public void WritePackageZipFileExploded(string zipFile, string directoryName)
  • public void WritePackageZipFileWasSameVersionAsExploded(string file)
  • public void WritePackageZipsFound(string applicationDirectory, IEnumerable<string> packageFileNames)
• public class ExplodeDirectory
  • public string BottleDirectory { get; set; }
  • public string PackageDirectory { get; set; }
• public interface IPackageExploder
• public interface IPackageExploderLogger
• public class PackageExploder : IPackageExploder
• public class PackageExploderLogger : IPackageExploderLogger
• public interface IBottleExploder
  • void CleanAll(string applicationDirectory)
  • void Explode(string sourceZipFile, string destinationDirectory, ExplodeOptions options)
  • IEnumerable<string> ExplodeAllZipsAndReturnPackageDirectories(string applicationDirectory, IPackageLog log)
  • IEnumerable<string> ExplodeDirectory(ExplodeDirectory directory)
  • string ReadVersion(string directoryName)
• public interface IBottleExploderLogger
  • void WriteExistingDirectories(string applicationDirectory, IEnumerable<string> existingDirectories)
  • void WritePackageDirectoryDeleted(string directoryName)
  • void WritePackageZipFileExploded(string zipFile, string directoryName)
  • void WritePackageZipFileWasSameVersionAsExploded(string file)
  • void WritePackageZipsFound(string applicationDirectory, IEnumerable<string> packageFileNames)

Bottles.Manifest

• public class Dependency
  • public bool IsMandatory { get; set; }
  • public string Name { get; set; }
  • public Dependency()
  • public static Dependency Mandatory(string name)
  • public static Dependency Optional(string name)
  • public bool Equals(Dependency other)
• public class PackageManifestReader : IPackageManifestReader
  • public PackageManifestReader(IFileSystem fileSystem, Func<string, string> getContentFolderFromBottleFolder)
  • public static bool IsPotentiallyAnAssembly(string file)
  • public IPackageInfo LoadFromFolder(string packageDirectory)
  • public PackageManifest LoadFromStream(Stream stream)

Bottles.PackageLoaders.Assemblies

• public class AssemblyFileFinder : IAssemblyFileFinder
  • public AssemblyFileFinder(IFileSystem fileSystem)
  • public AssemblyFiles FindAssemblies(string binDirectory, IEnumerable<string> assembliesToFind)
• public class AssemblyFiles
  • public static AssemblyFiles Empty { get; }
  • public IEnumerable<string> Files { get; set; }
  • public IEnumerable<string> MissingAssemblies { get; set; }
  • public IEnumerable<string> PdbFiles { get; set; }
  • public bool Success { get; }
  • public AssemblyFiles()
• public class AssemblyLoader : IAssemblyLoader, IAssemblyRegistration
  • public static readonly string DIRECTLY_REGISTERED_MESSAGE
  • public IList<Assembly> Assemblies { get; }
  • public Func<string, Assembly> AssemblyFileLoader { get; set; }
  • public AssemblyLoader(IBottlingDiagnostics diagnostics)
  • public static Assembly LoadPackageAssemblyFromAppBinPath(string file)
  • public virtual void LoadAssembliesFromPackage(IPackageInfo packageInfo)
  • public void ReadPackage(IPackageInfo package, IPackageLog log)
• public class AssemblyPackageInfo : IPackageInfo, DescribesItself
  • public Dependency[] Dependencies { get; }
  • public string Description { get; }
  • public IPackageFiles Files { get; }
  • public PackageManifest Manifest { get; }
  • public string Name { get; }
  • public string Role { get; }
  • public AssemblyPackageInfo(Assembly assembly)
  • public static PackageManifest DetermineManifest(Assembly assembly)
  • public static AssemblyPackageInfo For(string fileName)
  • public void Describe(Description description)
  • public void ForFiles(string directory, string searchPattern, Action<string, Stream> fileCallback)
  • public void ForFolder(string folderName, Action<string> onFound)
  • public void LoadAssemblies(IAssemblyRegistration loader)
• public class AssemblyPackageLoader : IPackageLoader, DescribesItself
  • public AssemblyPackageLoader(Assembly assembly)
  • public void Describe(Description description)
  • public bool Equals(AssemblyPackageLoader other)
  • public IEnumerable<IPackageInfo> Load(IPackageLog log)
• public interface IAssemblyFileFinder
  • AssemblyFiles FindAssemblies(string binDirectory, IEnumerable<string> assembliesToFind)
• public interface IAssemblyLoader
  • void ReadPackage(IPackageInfo package, IPackageLog log)
• public interface IAssemblyRegistration
  • void LoadFromFile(string fileName, string assemblyName)
  • void Use(Assembly assembly)

Bottles.PackageLoaders.Directory

• public class DirectoryPackageLoader : IPackageLoader, DescribesItself
  • public DirectoryPackageLoader(string searchPoint)
  • public void Describe(Description description)
  • public IEnumerable<IPackageInfo> Load(IPackageLog log)

Bottles.PackageLoaders.LinkedFolders

• public interface ILinksService
  • LinkManifest GetLinkManifest(string path)
  • bool LinkManifestExists(string path)
  • void Save(LinkManifest manifest, string path)
• public class LinkedFolderPackageLoader : IPackageLoader, DescribesItself
  • public LinkedFolderPackageLoader(string applicationDirectory, Func<string, string> getContentFolderFromPackageFolder)
  • public void Describe(Description description)
  • public IEnumerable<IPackageInfo> Load(IPackageLog log)
• public class LinkManifest
  • public static readonly string FILE
  • public string[] LinkedFolders { get; set; }
  • public RemoteLink[] RemoteLinks { get; set; }
  • public LinkManifest()
  • public bool AddLink(string folder)
  • public RemoteLink AddRemoteLink(LinkInput input)
  • public void AddRemoteLink(RemoteLink link)
  • public void RemoveAllLinkedFolders()
  • public void RemoveLink(string folder)
• public class LinksService : ILinksService
  • public LinksService(IFileSystem fileSystem)
  • public LinkManifest GetLinkManifest(string path)
  • public bool LinkManifestExists(string path)
  • public void Save(LinkManifest manifest, string path)
• public class RemoteLink
  • public string BootstrapperName { get; set; }
  • public string ConfigFile { get; set; }
  • public string Folder { get; set; }
  • public RemoteLink()

Bottles.Services

• public class ServiceInfo
• public class ApplicationLoader<TSource, TApplication, TRuntime> : IApplicationLoader where TSource : IApplicationSource<TApplication, TRuntime> where TApplication : IApplication<TRuntime> where TRuntime : IDisposable
  • public ApplicationLoader()
  • public IDisposable Load()
• public class BootstrapperApplicationLoader<T> : IApplicationLoader, IDisposable where T : IBootstrapper
  • public BootstrapperApplicationLoader()
  • public void Dispose()
  • public IDisposable Load()
• public class BottleService : IBottleService
  • public BottleService(IActivator activator, IPackageLog log)
  • public static BottleService For(IActivator service)
  • public static bool IsBottleService(Type type)
  • public static bool IsBottleService(object service)
  • public bool Equals(BottleService other)
  • public void Start()
  • public void Stop()
  • public Task ToTask()
• public static class BottleServiceApplication
  • public static IApplicationLoader BuildApplicationLoader(Type type)
  • public static Type DetermineLoaderType(Type type)
  • public static IApplicationLoader FindLoader(string bootstrapperType)
  • public static IEnumerable<Type> FindLoaderTypes()
  • public static bool IsLoaderTypeCandidate(Type type)
• public class BottleServiceAttribute : Attribute
  • public BottleServiceAttribute()
• public class BottleServiceBootstrapper : IBootstrapper
  • public BottleServiceBootstrapper()
  • public IEnumerable<IActivator> Bootstrap(IPackageLog log)
  • public IEnumerable<IBottleService> Services()
• public class BottleServiceConfiguration
  • public const string FILE = "bottle-service.config"
  • public string BootstrapperType { get; set; }
  • public string Description { get; set; }
  • public string DisplayName { get; set; }
  • public string Name { get; set; }
  • public bool UseEventLog { get; set; }
  • public BottleServiceConfiguration()
• public static class BottleServiceFinder
  • public static IEnumerable<Type> FilterTypes(this IEnumerable<Assembly> packageAssemblies, Func<Type, bool> predicate)
  • public static IEnumerable<IBottleService> Find(IEnumerable<Assembly> packageAssemblies, IPackageLog log)
  • public static IEnumerable<IBootstrapper> FindBootstrappers(IEnumerable<Assembly> packageAssemblies)
  • public static IEnumerable<Type> FindTypes(IEnumerable<Assembly> packageAssemblies)
• public class BottleServicePackageLoader : IPackageLoader
  • public BottleServicePackageLoader()
  • public IEnumerable<IPackageInfo> Load(IPackageLog log)
• public class BottleServiceRuntime
  • public BottleServiceRuntime(BottleServiceConfiguration configuration)
  • public void Start()
  • public void Stop()
• public class BottlesServicePackageFacility : PackageFacility
  • public BottlesServicePackageFacility()
  • public static string GetApplicationDirectory()
  • public IEnumerable<IBottleService> Services()
• public class DefaultBottleApplication : IApplicationLoader, IDisposable
  • public DefaultBottleApplication()
  • public void Dispose()
  • public IDisposable Load()
• public interface IApplication<T> where T : IDisposable
  • T Bootstrap()
• public interface IApplicationLoader
  • IDisposable Load()
• public interface IApplicationSource<TApplication, TRuntime> where TApplication : IApplication<TRuntime> where TRuntime : IDisposable
  • TApplication BuildApplication()
• public interface IBottleService
  • void Start()
  • void Stop()
  • Task ToTask()
• public static class JsonSerialization
  • public static string ToJson(object o, bool indentedFormatting = false)
• public static class Wait
  • public static bool Until(Func<bool> condition, int millisecondPolling = 500, int timeoutInMilliseconds = 5000)
• public class WrappedBootstrapper : IBootstrapper
  • public WrappedBootstrapper(IBootstrapper inner)
  • public IEnumerable<IActivator> Bootstrap(IPackageLog log)
  • public IEnumerable<IBottleService> BottleServices()

Bottles.Services.Messaging

• public static class EventAggregator
  • public static IMessagingHub Messaging { get; }
  • public static void ReceivedMessage(object message)
  • public static void SendMessage(string category, string message)
  • public static void SendMessage<T>(T message)
  • public static void SentMessage(object message)
  • public static void Start(IRemoteListener remoteListener)
  • public static void Stop()
• public interface IListener
  • void Receive<T>(T message)
• public interface IListener<T>
  • void Receive(T message)
• public interface IMessagingHub
  • IEnumerable<object> Listeners { get; }
  • void AddListener(object listener)
  • void RemoveListener(object listener)
  • void Send<T>(T message)
  • void SendJson(string json)
• public interface IRemoteListener
  • void Send(string json)
• public class MessageWaitCondition<T> : IListener<T>
  • public T Received { get; }
  • public MessageWaitCondition(Func<T, bool> filter)
  • public void Receive(T message)
  • public T Wait(int wait = 5000)
• public class MessagingHub : IMessagingHub
  • public interface ISender
  • public class Sender<T> : ISender
  • public IEnumerable<object> Listeners { get; }
  • public MessagingHub()
  • public static string ToJson(object o)
  • public void AddListener(object listener)
  • public void RemoveListener(object listener)
  • public void Send<T>(T message)
  • public void SendJson(string json)
• public static class MessagingHubExtensions
  • public static T WaitForMessage<T>(this IMessagingHub hub, Func<T, bool> filter, Action action, int wait = 5000)
  • public static T WaitForMessage<T>(this IMessagingHub hub, Action action, int wait = 5000)
• public class RemoteListener : MarshalByRefObject, IRemoteListener
  • public RemoteListener(IMessagingHub messagingHub)
  • public void Send(string json)
  • public void SendObject(object message)
  • public T WaitForMessage<T>(Func<T, bool> filter, Action action, int wait = 5000)
• public class ServiceMessage
  • public string Category { get; set; }
  • public string Message { get; set; }
  • public ServiceMessage()
  • protected bool Equals(ServiceMessage other)

Bottles.Services.Messaging.Tracking

• public class AllMessagesComplete
  • public AllMessagesComplete()
• public static class MessageHistory
  • public class MessageTrackListener : IListener<MessageTrack>
  • public static IEnumerable<MessageTrack> All()
  • public static void ClearAll()
  • public static void ClearHistory()
  • public static IEnumerable<MessageTrack> Outstanding()
  • public static IEnumerable<MessageTrack> Received()
  • public static void Record(MessageTrack track)
  • public static void StartListening(RemoteServiceRunner[] runners)
  • public static bool WaitForWorkToFinish(Action action, int timeoutMilliseconds = 5000)
• public class MessageTrack
  • public static readonly string Received
  • public static readonly string Sent
  • public string Description { get; set; }
  • public string FullName { get; set; }
  • public string Id { get; set; }
  • public string Status { get; set; }
  • public DateTime Timestamp { get; set; }
  • public string Type { get; set; }
  • public MessageTrack()
  • public static MessageTrack ForReceived(object message, string id = null)
  • public static MessageTrack ForSent(object message, string id = null)
  • protected bool Equals(MessageTrack other)

Bottles.Services.Remote

• public class AppDomainFileChangeWatcher : IDisposable
  • public AppDomainFileChangeWatcher(Action callback)
  • public void Dispose()
  • public void WatchBinariesAt(string directory)
• public enum AssemblyCopyMode
  • Always = 1
  • Once = 0
  • SemVerCompatible = 2
• public class AssemblyRequirement
  • public AssemblyRequirement(string name)
  • public AssemblyRequirement(string name, AssemblyCopyMode copyMode)
  • public AssemblyRequirement(Assembly assembly)
  • public AssemblyRequirement(Assembly assembly, AssemblyCopyMode copyMode)
  • public static Version AssemblyVersionOf(string filePath)
  • public static bool IsSemVerCompatible(string source, string destination)
  • public static bool IsSemVerCompatible(Version sourceVersion, Version destinationVersion)
  • public void Move(string directory)
  • public bool ShouldCopyFile(string fileName, string directory)
• public interface IAssemblyMover
  • void MoveAssemblies(AppDomainSetup setup)
• public class LoaderStarted
  • public string LoaderTypeName { get; set; }
  • public LoaderStarted()
• public class RemoteDomainExpression : IAssemblyMover
  • public readonly Cache<string, string> Properties
  • public AssemblyCopyMode AssemblyCopyMode { get; set; }
  • public string BootstrapperName { get; set; }
  • public MessagingHub Listeners { get; }
  • public string ServiceDirectory { get; set; }
  • public AppDomainSetup Setup { get; }
  • public RemoteDomainExpression()
  • public void LoadAssemblyContainingType<T>(string compileTarget = "Debug")
  • public void RequireAssembly(string name, AssemblyCopyMode copyMode)
  • public void RequireAssembly(string name)
  • public void RequireAssemblyContainingType<T>()
  • public void RequireAssemblyContainingType<T>(AssemblyCopyMode copyMode)
  • public void UseParallelServiceDirectory(string directory)
• public class RemoteService
  • public RemoteServiceRunner Runner { get; }
  • public string ServiceDirectory { get; }
  • public RemoteService(RemoteLink link)
  • public static IEnumerable<RemoteService> LoadLinkedRemotes()
  • public void Recycle()
  • public Task Start()
• public class RemoteServiceRunner : IDisposable, IListener<ServiceStarted>
  • public IMessagingHub Messaging { get; }
  • public IEnumerable<ServiceStarted> Started { get; }
  • public RemoteServiceRunner(Action<RemoteDomainExpression> configure)
  • public RemoteServiceRunner(string path, string binPath = null, string configFile = null)
  • public static RemoteServiceRunner For<T>(Action<RemoteDomainExpression> configure = null)
  • public void Dispose()
  • public void Recycle()
  • public void SendRemotely<T>(T message)
  • public T WaitForMessage<T>(Action action = null, int wait = 5000)
  • public T WaitForMessage<T>(Func<T, bool> filter, Action action = null, int wait = 5000)
  • public void WaitForServiceToStart<T>() where T : IActivator
• public class RemoteServicesProxy : MarshalByRefObject
  • public RemoteServicesProxy()
  • public void SendJson(string json)
  • public void Shutdown()
  • public void Start(string bootstrapperName, MarshalByRefObject remoteListener)
  • public void Start(string bootstrapperName, Dictionary<string, string> properties, MarshalByRefObject remoteListener)
• public class ServiceStarted
  • public string ActivatorTypeName { get; set; }
  • public ServiceStarted()