/// <summary>
        /// Loads a command store using the metadata for one of the branches
        /// in the store.
        /// </summary>
        /// <param name="sqliteFilename">The file specification of the SQLite database
        /// to load.</param>
        /// <param name="cs">Details for a clone command that should be used
        /// to initialize the root metadata for a newly cloned store (specify
        /// null if this store previously existed).</param>
        /// <returns>The loaded command store.</returns>
        public static SQLiteStore Load(string sqliteFilename, ICloneStore cs = null)
        {
            var db = new SQLiteDatabase(sqliteFilename);

            // Load misc properties
            Dictionary <string, object> props = db.ExecuteQuery(new PropertiesQuery())
                                                .ToDictionary(x => x.Key, x => (object)x.Value);

            // Amend root details if we're loading up a new clone
            if (cs != null)
            {
                Guid upstreamId = props.GetGuid(PropertyNaming.StoreId.ToString());
                props[PropertyNaming.UpstreamId.ToString()]       = upstreamId;
                props[PropertyNaming.UpstreamLocation.ToString()] = cs.Origin;
                props[PropertyNaming.StoreId.ToString()]          = cs.StoreId;
            }

            var root = new StoreInfo(
                storeId: props.GetGuid(PropertyNaming.StoreId.ToString()),
                name: Path.GetFileNameWithoutExtension(sqliteFilename),
                upstreamId: props.GetGuid(PropertyNaming.UpstreamId.ToString()),
                upstreamLocation: props.GetValue <string>(PropertyNaming.UpstreamLocation.ToString()),
                pushTimes: null);

            // Fake a directory name that will provide a value for CmdStore.Name that
            // corresponds to the name of the database
            string rootDirectoryName = Path.ChangeExtension(sqliteFilename, null);

            // What was the last branch the user was working with? (it should be defined,
            // go with the master branch if not)
            var curId = props.GetGuid(PropertyNaming.LastBranch.ToString());

            if (Guid.Empty.Equals(curId))
            {
                curId = root.StoreId;
            }

            // Load metadata for all branches in the store
            BranchInfo[] acs = db.ExecuteQuery(new BranchesQuery())
                               .OrderBy(x => x.CreatedAt)
                               .ToArray();

            Debug.Assert(acs.Length > 0);
            Debug.Assert(acs.Any(x => x.BranchId.Equals(curId)));

            var result = new SQLiteStore(root, acs, curId, db);

            // If we amended the store properties for a new clone, save
            // them back to the database
            if (cs != null)
            {
                result.SaveStoreInfo();
            }

            return(result);
        }
Beispiel #2
0
        /// <summary>
        /// Obtains some sort of channel to the store that acts
        /// as the origin for the clone.
        /// </summary>
        /// <returns>Something that provides the command structure
        /// for a store. This implementation just returns a supplier
        /// that corresponds to a local file store.</returns>
        static IRemoteStore GetRemoteStore(ICloneStore cs)
        {
            string origin = cs.Origin;
            string acPath = GetAcFilePath(origin);

            if (acPath == null)
            {
                throw new ApplicationException("Cannot locate any AC file in source");
            }

            var result = FileStore.Load(acPath);

            Log.Info($"Cloning from {result.Name}");
            return(result);
        }
Beispiel #3
0
        internal static FileStore Create(CmdData args)
        {
            // Expand the supplied name to include the current working directory (or
            // expand a relative path)
            string enteredName = args.GetValue <string>(nameof(ICreateStore.Name));
            string name        = Path.GetFileNameWithoutExtension(enteredName);
            string folderName  = Path.GetFullPath(enteredName);

            // Disallow if the folder name already exists.

            // It may be worth relaxing this rule at some future date. The
            // reason for disallowing it is because an existing folder may
            // well contain sub-folders, but we also use sub-folders to
            // represent the branch hierarchy. So things would be a bit
            // mixed up. That said, it would be perfectly plausible to
            // place branch sub-folders under a separate ".ac" folder (in
            // much the same way as git). That might be worth considering
            // if we want to support a "working directory" like that
            // provided by git.

            if (Directory.Exists(folderName))
            {
                throw new ApplicationException($"{folderName} already exists");
            }

            // Confirm the folder is on a local drive
            if (!IsLocalDrive(folderName))
            {
                throw new ApplicationException("Command stores can only be initialized on a local fixed drive");
            }

            // Create the folder for the store (but if the folder already exists,
            // confirm that it does not already hold any AC files).
            if (Directory.Exists(folderName))
            {
                if (GetAcFilePath(folderName) != null)
                {
                    throw new ApplicationException($"{folderName} has already been initialized");
                }
            }
            else
            {
                Log.Info("Creating " + folderName);
                Directory.CreateDirectory(folderName);
            }

            Guid      storeId = args.GetGuid(nameof(ICreateStore.StoreId));
            FileStore result  = null;

            // If we're cloning, copy over the source data
            if (args.CmdName == nameof(ICloneStore))
            {
                // TODO: When cloning from a real remote, using wget might be a
                // good choice (but that doesn't really fit with what's below)

                ICloneStore  cs = (args as ICloneStore);
                IRemoteStore rs = GetRemoteStore(cs);

                // Retrieve metadata for all remote branches
                BranchInfo[] acs = rs.GetBranches()
                                   .OrderBy(x => x.CreatedAt)
                                   .ToArray();

                var branchFolders = new Dictionary <Guid, string>();

                // Copy over all branches
                foreach (BranchInfo ac in acs)
                {
                    // Get the data for the branch (do this before we do any tweaking
                    // of the folder path from the AC file -- if the command supplier is
                    // a local file store, we won't be able to read the command data files
                    // after changing the folder name recorded in the AC)
                    IdRange   range = new IdRange(ac.BranchId, 0, ac.CommandCount - 1);
                    CmdData[] data  = rs.GetData(range).ToArray();

                    // TODO: what follows is very similar to the CopyIn method.
                    // Consider using that instead (means an empty FileStore needs
                    // to be created up front)

                    // Determine the output location for the AC file (relative to the
                    // location that should have already been defined for the parent)

                    if (!branchFolders.TryGetValue(ac.ParentId, out string parentFolder))
                    {
                        Debug.Assert(ac.ParentId.Equals(Guid.Empty));
                        parentFolder = folderName;
                    }

                    string dataFolder = Path.Combine(parentFolder, ac.BranchName);
                    branchFolders[ac.BranchId] = dataFolder;
                    SaveBranchInfo(dataFolder, ac);

                    // Copy over the command data
                    foreach (CmdData cd in data)
                    {
                        FileStore.WriteData(dataFolder, cd);
                    }
                }

                // If the origin is a folder on the local file system, ensure it's
                // saved as an absolute path (relative specs may confuse directory
                // navigation, depending on what the current directory is at the time)

                string origin = cs.Origin;
                if (Directory.Exists(origin))
                {
                    origin = Path.GetFullPath(origin);
                }

                // Save the store metadata
                var root = new StoreInfo(storeId, name, rs.Id, origin);
                SaveStoreInfo(folderName, root);

                // And suck it back up again
                string acSpec = Path.Combine(folderName, acs[0].BranchId + ".ac");
                result = FileStore.Load(acSpec);
            }
            else
            {
                // Create the AC file that represents the store root branch
                var ac = new BranchInfo(storeId: storeId,
                                        parentId: Guid.Empty,
                                        branchId: storeId,
                                        branchName: name,
                                        createdAt: args.CreatedAt);

                // Create the store metadata
                var storeInfo = new StoreInfo(storeId, name, Guid.Empty);

                // Create the store and save it
                result = new FileStore(folderName,
                                       storeInfo,
                                       new BranchInfo[] { ac },
                                       ac.BranchId);

                // Save the AC file plus the store metadata
                FileStore.SaveBranchInfo(folderName, ac);
                result.SaveStoreInfo();
            }

            return(result);
        }
        internal static SQLiteStore Create(CmdData args)
        {
            // Disallow store names that correspond to tables in the database (bear
            // in mind that the entered name may or may not include a directory path)
            string enteredName = args.GetValue <string>(nameof(ICreateStore.Name));
            string name        = Path.GetFileNameWithoutExtension(enteredName);

            if (IsReservedName(name))
            {
                throw new ApplicationException("Store name not allowed");
            }

            // Expand the supplied name to include the current working directory (or
            // expand a relative path)
            string fullSpec = Path.GetFullPath(enteredName);
            string fileType = Path.GetExtension(fullSpec);

            if (String.IsNullOrEmpty(fileType))
            {
                fullSpec += ".ac-sqlite";
            }

            // Disallow if the database file already exists
            if (File.Exists(fullSpec))
            {
                throw new ApplicationException($"{fullSpec} already exists");
            }

            // Confirm the file is on a local drive
            if (!IsLocalDrive(fullSpec))
            {
                throw new ApplicationException("Command stores can only be initialized on a local fixed drive");
            }

            // Ensure the folder exists
            string folderName = Path.GetDirectoryName(fullSpec);

            if (!Directory.Exists(folderName))
            {
                Log.Trace("Creating " + folderName);
                Directory.CreateDirectory(folderName);
            }

            Guid        storeId = args.GetGuid(nameof(ICreateStore.StoreId));
            SQLiteStore result  = null;

            if (args.CmdName == nameof(ICloneStore))
            {
                // Copy the SQLite database
                // TODO: To handle database files on remote machines
                ICloneStore cs = (args as ICloneStore);
                Log.Info($"Copying {cs.Origin} to {fullSpec}");
                File.Copy(cs.Origin, fullSpec);

                // Load the copied store
                result = SQLiteStore.Load(fullSpec, cs);
            }
            else
            {
                Log.Info("Creating " + fullSpec);
                SQLiteDatabase db = CreateDatabase(fullSpec);

                // Create the AC file that represents the store root branch
                var ac = new BranchInfo(storeId: storeId,
                                        parentId: Guid.Empty,
                                        branchId: storeId,
                                        branchName: name,
                                        createdAt: args.CreatedAt);

                // Create the store metadata
                var storeInfo = new StoreInfo(storeId, name, Guid.Empty);

                // Create the store and save it
                result = new SQLiteStore(storeInfo,
                                         new BranchInfo[] { ac },
                                         ac.BranchId,
                                         db);

                // Save the info for the master branch plus the store metadata
                result.SaveBranchInfo(ac);
                result.SaveStoreInfo();

                // The last branch is the root of the new database
                result.SaveProperty(PropertyNaming.LastBranch, storeId.ToString());
            }

            return(result);
        }