Beispiel #1
0
        /// <summary>
        ///     Adds a <see cref="IPackageArchive"/> from the specified binary <paramref name="data"/>.
        /// </summary>
        /// <remarks>
        ///     The resulting Package archive file is saved to the Packages directory with a filename composed of the Fully
        ///     Qualified Name and Version of the Package.
        /// </remarks>
        /// <param name="data">The binary data to save.</param>
        /// <returns>A Result containing the result of the operation and the created <see cref="IPackageArchive"/> instance.</returns>
        public IResult <IPackageArchive> AddPackageArchive(byte[] data)
        {
            Guid guid = logger.EnterMethod();

            logger.Info("Creating new Package...");

            IResult <IPackageArchive> retVal = new Result <IPackageArchive>();
            string tempFile            = Path.Combine(PlatformManager.Directories.Temp, Guid.NewGuid().ToString());
            string destinationFilename = default(string);

            if (data.Length == 0)
            {
                retVal.AddError($"The specified binary payload is empty.");
            }
            else
            {
                logger.Debug($"Saving new Package to '{tempFile}'...");
                retVal.Incorporate(Platform.WriteFileBytes(tempFile, data));

                if (retVal.ResultCode != ResultCode.Failure)
                {
                    IResult <IPackageArchive> readResult = PackageFactory.GetPackageArchive(tempFile);

                    retVal.Incorporate(readResult);

                    if (retVal.ResultCode != ResultCode.Failure)
                    {
                        IPackageArchive package = readResult.ReturnValue;

                        destinationFilename = package.FQN + "." + package.Manifest.Version + PackagingConstants.PackageFilenameExtension;
                        destinationFilename = ReplaceInvalidCharacters(destinationFilename);
                        destinationFilename = Path.Combine(PlatformManager.Directories.PackageArchives, destinationFilename);

                        logger.Debug($"Copying temporary Package '{tempFile}' to final destination '{destinationFilename}'...");
                        retVal.Incorporate(Platform.CopyFile(tempFile, destinationFilename, true));

                        if (retVal.ResultCode != ResultCode.Failure)
                        {
                            ScanPackageArchives();
                            retVal.ReturnValue = FindPackageArchive(readResult.ReturnValue.FQN);
                        }
                    }
                }
            }

            if (retVal.ResultCode != ResultCode.Failure)
            {
                logger.Debug($"Package Archive successfully saved to {destinationFilename}. Sending PackageArchiveAdded Event...");
                Task.Run(() => PackageArchiveAdded?.Invoke(this, new PackageArchiveEventArgs(retVal.ReturnValue)));
            }

            retVal.LogResult(logger);
            logger.ExitMethod(guid);
            return(retVal);
        }
        /// <summary>
        ///     Scans the directory specified in <see cref="Platform.Directories.PackageArchives"/> for
        ///     <see cref="IPackageArchive"/> s.
        /// </summary>
        /// <returns>
        ///     A Result containing the result of the operation and a <see cref="List{T}"/> of found <see cref="IPackageArchive"/> s.
        /// </returns>
        public IResult <IList <IPackageArchive> > ScanPackageArchives()
        {
            Guid guid = logger.EnterMethod(true);

            logger.Info("Scanning for Package Archives...");

            IResult <IList <IPackageArchive> > retVal = new Result <IList <IPackageArchive> >();

            retVal.ReturnValue = new List <IPackageArchive>();

            string searchDirectory = PlatformManager.Directories.PackageArchives;

            logger.Debug($"Scanning directory '{searchDirectory}'...");

            IResult <IList <string> > fileListResult = Platform.ListFiles(searchDirectory);

            retVal.Incorporate(fileListResult);

            if (retVal.ResultCode != ResultCode.Failure)
            {
                foreach (string file in fileListResult.ReturnValue)
                {
                    IResult <IPackageArchive> readResult = PackageFactory.GetPackageArchive(file);

                    if (readResult.ResultCode != ResultCode.Failure)
                    {
                        retVal.Incorporate(readResult);
                        retVal.ReturnValue.Add(readResult.ReturnValue);
                    }
                    else
                    {
                        retVal.AddWarning(readResult.GetLastError());
                    }
                }
            }

            retVal.LogResult(logger);
            logger.ExitMethod(guid);

            return(retVal);
        }