/// <summary> /// Adds a new child. /// </summary> /// <param name="persistenceInformation">The persistence information that describes the dataset that should be copied.</param> /// <returns> /// The newly created dataset. /// </returns> public DatasetFacade AddChild(IPersistenceInformation persistenceInformation) { { Enforce.Argument(() => persistenceInformation); } // For user created datasets we have some default settings: // - We don't ever allow nodes to be adopted, it just creates too much of a hassle with // updating the node links etc. // - We always allow user created datasets to become parents, they may need to split // of their calculations // - We allow all user created datasets to be copied // - User created datasets can always be deleted var creationInformation = new DatasetCreationInformation { CanBeAdopted = false, CanBecomeParent = true, CanBeCopied = true, CanBeDeleted = true, CreatedOnRequestOf = DatasetCreator.User, LoadFrom = persistenceInformation, }; var child = m_Dataset.CreateNewChild(creationInformation); return(new DatasetFacade(child)); }
/// <summary> /// Loads a new project from the given resource stream. /// </summary> /// <param name="persistenceInformation">The object that describes how the project was persisted.</param> public void LoadProject(IPersistenceInformation persistenceInformation) { if (!CanLoadProject()) { throw new CannotLoadProjectException(); } var context = new LoadProjectContext { LoadFrom = persistenceInformation }; Debug.Assert(m_Service.Contains(LoadProjectCommand.CommandId), "A command has gone missing."); m_Service.Invoke(LoadProjectCommand.CommandId, context); var project = context.Result; if (project == null) { throw new FailedToLoadProjectException(); } m_Facade = new ProjectFacade(project.Result); RaiseOnNewProjectLoaded(); }
/// <summary> /// Saves the existing project. /// </summary> /// <param name="projectFacade">The object that contains the methods that allow interaction with the project system.</param> /// <param name="persistenceInformation">The object that describes how the project should be persisted.</param> /// <param name="timer">The function that creates and stores timing intervals.</param> private static void OnSaveProject( ILinkToProjects projectFacade, IPersistenceInformation persistenceInformation, Func <string, IDisposable> timer) { // If there is no facade then we're in design mode or something // else weird. if (projectFacade == null) { return; } if (!projectFacade.HasActiveProject()) { return; } using (timer("Saving project")) { var project = projectFacade.ActiveProject(); project.SaveProject(persistenceInformation); projectFacade.ActiveProject().History.Mark(Resources.SaveProjectCommand_HistoryMark); } }
/// <summary> /// Creates a new project definition object. /// </summary> /// <returns> /// The current builder instance with all the storage cleared. /// </returns> public IBuildProjects Define() { m_Distributor = null; m_ProjectStorage = null; return(this); }
/// <summary> /// Initializes a new instance of the <see cref="Project"/> class. /// </summary> /// <param name="timeline">The timeline for the current project.</param> /// <param name="distributor"> /// The function which returns a <see cref="DistributionPlan"/> for a given /// <see cref="DatasetActivationRequest"/>. /// </param> /// <param name="dataStorageProxyBuilder">The function which returns a storage proxy for a newly loaded dataset.</param> /// <param name="notifications">The object that stores the notifications for the user interface.</param> /// <param name="diagnostics">The object that provides the diagnostics methods for the application.</param> /// <param name="persistenceInfo"> /// The object that describes how the project was persisted. /// </param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="timeline"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown when <paramref name="distributor"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown when <paramref name="dataStorageProxyBuilder"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown when <paramref name="notifications"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown when <paramref name="diagnostics"/> is <see langword="null" />. /// </exception> public Project( ITimeline timeline, Func <DatasetActivationRequest, CancellationToken, IEnumerable <DistributionPlan> > distributor, Func <DatasetOnlineInformation, DatasetStorageProxy> dataStorageProxyBuilder, ICollectNotifications notifications, SystemDiagnostics diagnostics, IPersistenceInformation persistenceInfo) { { Lokad.Enforce.Argument(() => timeline); Lokad.Enforce.Argument(() => distributor); Lokad.Enforce.Argument(() => dataStorageProxyBuilder); Lokad.Enforce.Argument(() => notifications); Lokad.Enforce.Argument(() => diagnostics); } m_Timeline = timeline; m_Timeline.ForgetAllHistory(); m_Timeline.OnRolledBack += OnTimelineRolledBack; m_Timeline.OnRolledForward += OnTimelineRolledForward; m_ProjectInformation = m_Timeline.AddToTimeline(ProjectHistoryStorage.CreateInstance); m_Datasets = m_Timeline.AddToTimeline(DatasetHistoryStorage.CreateInstance); m_DatasetDistributor = distributor; m_DataStorageProxyBuilder = dataStorageProxyBuilder; m_Notifications = notifications; m_Diagnostics = diagnostics; if (persistenceInfo != null) { RestoreFromStore(persistenceInfo); } // Create a root dataset if there isn't one if (m_RootDataset == null) { var dataset = CreateDataset( null, new DatasetCreationInformation { CreatedOnRequestOf = DatasetCreator.System, LoadFrom = new NullPersistenceInformation(), CanBeDeleted = false, CanBeCopied = false, CanBecomeParent = true, CanBeAdopted = false, IsRoot = true, }); m_RootDataset = dataset.Id; dataset.Name = Resources.Projects_Dataset_RootDatasetName; dataset.Summary = Resources.Projects_Dataset_RootDatasetSummary; } m_Timeline.SetCurrentAsDefault(); }
/// <summary> /// Saves the current project. /// </summary> /// <param name="persistenceInformation">The object that describes how the project should be persisted.</param> public void SaveProject(IPersistenceInformation persistenceInformation) { if (m_Current != null) { m_Current.Save(persistenceInformation); HasProjectChanged = false; } }
/// <summary> /// Provides the <see cref="Stream"/> from which the project must be loaded. /// </summary> /// <param name="persistenceInfo"> /// The object that describes how the project was persisted. /// </param> /// <returns> /// The current builder instance with the stream containing the project stored. /// </returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="persistenceInfo"/> is <see langword="null" />. /// </exception> public IBuildProjects FromStorage(IPersistenceInformation persistenceInfo) { { Lokad.Enforce.Argument(() => persistenceInfo); } m_ProjectStorage = persistenceInfo; return(this); }
/// <summary> /// Saves the project and all the datasets to the given stream. /// </summary> /// <param name="persistenceInfo"> /// The object that describes how the project should be persisted. /// </param> /// <remarks> /// Note that saving project and dataset information to a stream on the local machine may take /// some time because the datasets may be large, reside on a remote machine or both. /// </remarks> public void Save(IPersistenceInformation persistenceInfo) { { Lokad.Enforce.With <CannotUseProjectAfterClosingItException>( !IsClosed, Resources.Exceptions_Messages_CannotUseProjectAfterClosingIt); Lokad.Enforce.Argument(() => persistenceInfo); } // Do we need to have a save flag that we can set to prevent closing from happening // while saving? throw new NotImplementedException(); }
/// <summary> /// Loads a new project. /// </summary> /// <param name="projectFacade">The object that contains the methods that allow interaction with the project system.</param> /// <param name="persistenceInformation">The object that describes how the project was persisted.</param> /// <param name="timer">The function that creates and stores timing intervals.</param> private static void OnLoadProject( ILinkToProjects projectFacade, IPersistenceInformation persistenceInformation, Func <string, IDisposable> timer) { // If there is no facade then we're in design mode or something // else weird. if (projectFacade == null) { return; } using (timer("Loading project")) { projectFacade.LoadProject(persistenceInformation); } }
/// <summary> /// Exports the given dataset as the base of a new project. /// </summary> /// <param name="datasetToExport"> /// The ID number of the dataset that should be exported. /// </param> /// <param name="shouldIncludeChildren"> /// Indicates if all the child datasets of <paramref name="datasetToExport"/> should be included in the /// export or not. /// </param> /// <param name="persistenceInfo"> /// The object that describes how the dataset should be exported. /// </param> /// <remarks> /// Note that saving project and dataset information to a stream on the local machine may take /// some time because the datasets may be large, reside on a remote machine or both. /// </remarks> public void Export(DatasetId datasetToExport, bool shouldIncludeChildren, IPersistenceInformation persistenceInfo) { { Lokad.Enforce.With <CannotUseProjectAfterClosingItException>( !IsClosed, Resources.Exceptions_Messages_CannotUseProjectAfterClosingIt); Lokad.Enforce.Argument(() => datasetToExport); Lokad.Enforce.With <UnknownDatasetException>( m_Datasets.Datasets.ContainsKey(datasetToExport), Resources.Exceptions_Messages_UnknownDataset_WithId, datasetToExport); Lokad.Enforce.Argument(() => persistenceInfo); } // Do we need to have a save flag that we can set to prevent closing from happening // while saving? throw new NotImplementedException(); }
private static DatasetId RestoreFromStore(IPersistenceInformation persistenceInfo) { // Restore the dataset here ... // Probably needs to be version safe etc. // Note that we also need to store the stream somewhere // so that we always have access to it (which will probably be on disk) // this may cause all kinds of untold chaos, e.g. // - disk full / not big enough // - The stream is a remote stream and cuts out half way (i.e we don't consume it on time) // // // When creating a dataset check: // - The root must not have parents // - Adding the dataset should not create any cycles // - No parent may become a child of a child node // OR better yet, no node may become a child after it is inserted return(new DatasetId()); }
/// <summary> /// Loads the project from the given stream. Note that in first instance /// only the project is loaded, the datasets will not be loaded /// until requested. /// </summary> /// <param name="persistenceInfo"> /// The object that describes how the project was persisted. /// </param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="persistenceInfo"/> is <see langword="null" />. /// </exception> public void LoadProject(IPersistenceInformation persistenceInfo) { { Lokad.Enforce.Argument(() => persistenceInfo); } UnloadProject(); lock (m_Lock) { m_Current = m_Builder.Define() .WithTimeline(m_TimelineBuilder()) .WithDatasetDistributor((request, token) => m_DatasetDistributor.ProposeDistributionFor(request, token)) .WithDataStorageBuilder(m_DataStorageProxyBuilder) .WithNotifications(m_Notifications) .WithDiagnostics(m_Diagnostics) .FromStorage(persistenceInfo) .Build(); } }
private static IDatasetOfflineInformation CreateOfflineInfo(IPersistenceInformation storage) { var mock = new Mock <IDatasetOfflineInformation>(); { mock.Setup(d => d.CanBeAdopted) .Returns(false); mock.Setup(d => d.CanBecomeParent) .Returns(true); mock.Setup(d => d.CanBeCopied) .Returns(false); mock.Setup(d => d.CanBeDeleted) .Returns(true); mock.Setup(d => d.CreatedBy) .Returns(DatasetCreator.User); mock.Setup(d => d.StoredAt) .Returns(storage); } return(mock.Object); }
private static DatasetId RestoreFromStore(IPersistenceInformation persistenceInfo) { // Restore the dataset here ... // Probably needs to be version safe etc. // Note that we also need to store the stream somewhere // so that we always have access to it (which will probably be on disk) // this may cause all kinds of untold chaos, e.g. // - disk full / not big enough // - The stream is a remote stream and cuts out half way (i.e we don't consume it on time) // // // When creating a dataset check: // - The root must not have parents // - Adding the dataset should not create any cycles // - No parent may become a child of a child node // OR better yet, no node may become a child after it is inserted return new DatasetId(); }
/// <summary> /// Saves the project and all the datasets to the given stream. /// </summary> /// <param name="persistenceInfo"> /// The object that describes how the project should be persisted. /// </param> /// <remarks> /// Note that saving project and dataset information to a stream on the local machine may take /// some time because the datasets may be large, reside on a remote machine or both. /// </remarks> public void Save(IPersistenceInformation persistenceInfo) { { Lokad.Enforce.With<CannotUseProjectAfterClosingItException>( !IsClosed, Resources.Exceptions_Messages_CannotUseProjectAfterClosingIt); Lokad.Enforce.Argument(() => persistenceInfo); } // Do we need to have a save flag that we can set to prevent closing from happening // while saving? throw new NotImplementedException(); }
/// <summary> /// Exports the given dataset as the base of a new project. /// </summary> /// <param name="datasetToExport"> /// The ID number of the dataset that should be exported. /// </param> /// <param name="shouldIncludeChildren"> /// Indicates if all the child datasets of <paramref name="datasetToExport"/> should be included in the /// export or not. /// </param> /// <param name="persistenceInfo"> /// The object that describes how the dataset should be exported. /// </param> /// <remarks> /// Note that saving project and dataset information to a stream on the local machine may take /// some time because the datasets may be large, reside on a remote machine or both. /// </remarks> public void Export(DatasetId datasetToExport, bool shouldIncludeChildren, IPersistenceInformation persistenceInfo) { { Lokad.Enforce.With<CannotUseProjectAfterClosingItException>( !IsClosed, Resources.Exceptions_Messages_CannotUseProjectAfterClosingIt); Lokad.Enforce.Argument(() => datasetToExport); Lokad.Enforce.With<UnknownDatasetException>( m_Datasets.Datasets.ContainsKey(datasetToExport), Resources.Exceptions_Messages_UnknownDataset_WithId, datasetToExport); Lokad.Enforce.Argument(() => persistenceInfo); } // Do we need to have a save flag that we can set to prevent closing from happening // while saving? throw new NotImplementedException(); }
/// <summary> /// Initializes a new instance of the <see cref="Project"/> class. /// </summary> /// <param name="timeline">The timeline for the current project.</param> /// <param name="distributor"> /// The function which returns a <see cref="DistributionPlan"/> for a given /// <see cref="DatasetActivationRequest"/>. /// </param> /// <param name="dataStorageProxyBuilder">The function which returns a storage proxy for a newly loaded dataset.</param> /// <param name="notifications">The object that stores the notifications for the user interface.</param> /// <param name="diagnostics">The object that provides the diagnostics methods for the application.</param> /// <param name="persistenceInfo"> /// The object that describes how the project was persisted. /// </param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="timeline"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown when <paramref name="distributor"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown when <paramref name="dataStorageProxyBuilder"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown when <paramref name="notifications"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown when <paramref name="diagnostics"/> is <see langword="null" />. /// </exception> public Project( ITimeline timeline, Func<DatasetActivationRequest, CancellationToken, IEnumerable<DistributionPlan>> distributor, Func<DatasetOnlineInformation, DatasetStorageProxy> dataStorageProxyBuilder, ICollectNotifications notifications, SystemDiagnostics diagnostics, IPersistenceInformation persistenceInfo) { { Lokad.Enforce.Argument(() => timeline); Lokad.Enforce.Argument(() => distributor); Lokad.Enforce.Argument(() => dataStorageProxyBuilder); Lokad.Enforce.Argument(() => notifications); Lokad.Enforce.Argument(() => diagnostics); } m_Timeline = timeline; m_Timeline.ForgetAllHistory(); m_Timeline.OnRolledBack += OnTimelineRolledBack; m_Timeline.OnRolledForward += OnTimelineRolledForward; m_ProjectInformation = m_Timeline.AddToTimeline(ProjectHistoryStorage.CreateInstance); m_Datasets = m_Timeline.AddToTimeline(DatasetHistoryStorage.CreateInstance); m_DatasetDistributor = distributor; m_DataStorageProxyBuilder = dataStorageProxyBuilder; m_Notifications = notifications; m_Diagnostics = diagnostics; if (persistenceInfo != null) { RestoreFromStore(persistenceInfo); } // Create a root dataset if there isn't one if (m_RootDataset == null) { var dataset = CreateDataset( null, new DatasetCreationInformation { CreatedOnRequestOf = DatasetCreator.System, LoadFrom = new NullPersistenceInformation(), CanBeDeleted = false, CanBeCopied = false, CanBecomeParent = true, CanBeAdopted = false, IsRoot = true, }); m_RootDataset = dataset.Id; dataset.Name = Resources.Projects_Dataset_RootDatasetName; dataset.Summary = Resources.Projects_Dataset_RootDatasetSummary; } m_Timeline.SetCurrentAsDefault(); }
/// <summary> /// Provides the <see cref="Stream"/> from which the project must be loaded. /// </summary> /// <param name="persistenceInfo"> /// The object that describes how the project was persisted. /// </param> /// <returns> /// The current builder instance with the stream containing the project stored. /// </returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="persistenceInfo"/> is <see langword="null" />. /// </exception> public IBuildProjects FromStorage(IPersistenceInformation persistenceInfo) { { Lokad.Enforce.Argument(() => persistenceInfo); } m_ProjectStorage = persistenceInfo; return this; }
/// <summary> /// Creates a new project definition object. /// </summary> /// <returns> /// The current builder instance with all the storage cleared. /// </returns> public IBuildProjects Define() { m_Distributor = null; m_ProjectStorage = null; return this; }
private static IDatasetOfflineInformation CreateOfflineInfo(IPersistenceInformation storage) { var mock = new Mock<IDatasetOfflineInformation>(); { mock.Setup(d => d.Id) .Returns(new DatasetId()); mock.Setup(d => d.CanBeAdopted) .Returns(false); mock.Setup(d => d.CanBecomeParent) .Returns(true); mock.Setup(d => d.CanBeCopied) .Returns(false); mock.Setup(d => d.CanBeDeleted) .Returns(true); mock.Setup(d => d.CreatedBy) .Returns(DatasetCreator.User); mock.Setup(d => d.StoredAt) .Returns(storage); } return mock.Object; }