Exemplo n.º 1
0
        public ServiceClientPartition(ImageProfileWithImage imageProfile)
        {
            string schema = null;

            if (imageProfile != null)
            {
                _imageProfile = imageProfile;
                if ((imageProfile.PartitionMethod == "Dynamic" || imageProfile.PartitionMethod == "Standard" ||
                     imageProfile.PartitionMethod == "Standard Core Storage") &&
                    !string.IsNullOrEmpty(imageProfile.CustomSchema))
                {
                    schema = imageProfile.CustomSchema;
                }
                else
                {
                    schema = new FilesystemServices().ReadSchemaFile(imageProfile.Image.Name);
                }
            }

            if (!string.IsNullOrEmpty(schema))
            {
                _imageSchema = JsonConvert.DeserializeObject <DtoImageSchema>(schema);
            }
        }
Exemplo n.º 2
0
        /// <summary>
        ///     Calculates the minimum block size required for a single partition, taking into account any children partitions.
        /// </summary>
        public PartitionHelper Partition(int hdNumberToGet, int partNumberToGet, long newHdSize)
        {
            var partition       = _imageSchema.HardDrives[hdNumberToGet].Partitions[partNumberToGet];
            var partitionHelper = new PartitionHelper {
                MinSizeBlk = 0
            };
            var extendedPartitionHelper = new ExtendedPartitionHelper();

            if (partition.Type.ToLower() == "extended")
            {
                extendedPartitionHelper = ExtendedPartition(hdNumberToGet, newHdSize);
            }

            partitionHelper.VolumeGroupHelper = VolumeGroup(hdNumberToGet, partNumberToGet, newHdSize);
            var lbsByte = _imageSchema.HardDrives[hdNumberToGet].Lbs;

            //Look if any volume groups are present for this partition.  If so set the volumesize for the volume group to the minimum size
            //required for the volume group.  Volume groups are always treated as resizable even if none of the individual
            //logical volumes are resizable
            if (partitionHelper.VolumeGroupHelper.Pv != null)
            {
                partitionHelper.PartitionHasVolumeGroup = true;
                partition.VolumeSize = partitionHelper.VolumeGroupHelper.MinSizeBlk * lbsByte / 1024 / 1024;
            }

            if (partition.ForceFixedSize)
            {
                partitionHelper.MinSizeBlk    = partition.Size;
                partitionHelper.IsDynamicSize = false;
            }
            //Use partition size that user has set for the partition, if it is set.
            else if (!string.IsNullOrEmpty(partition.CustomSize) && !string.IsNullOrEmpty(partition.CustomSizeUnit))
            {
                long customSizeBytes = 0;
                switch (partition.CustomSizeUnit)
                {
                case "MB":
                    customSizeBytes = Convert.ToInt64(partition.CustomSize) * 1024 * 1024;
                    break;

                case "GB":
                    customSizeBytes = Convert.ToInt64(partition.CustomSize) * 1024 * 1024 * 1024;
                    break;

                case "%":
                    var hdPercent = Convert.ToDouble(partition.CustomSize) / 100;
                    customSizeBytes = Convert.ToInt64(hdPercent * newHdSize);
                    break;
                }
                partitionHelper.MinSizeBlk    = customSizeBytes / lbsByte;
                partitionHelper.IsDynamicSize = false;
            }

            //If partition is not resizable.  Determine partition size.  Also if the partition is less than 5 gigs assume it is that
            // size for a reason, do not resize it even if it is marked as a resizable partition
            else if ((partition.VolumeSize == 0 && partition.Type.ToLower() != "extended") ||
                     (partition.Type.ToLower() == "extended" && extendedPartitionHelper.IsOnlySwap) ||
                     partition.Size * lbsByte <= 5368709120 || partition.FsType == "swap")
            {
                partitionHelper.MinSizeBlk    = partition.Size;
                partitionHelper.IsDynamicSize = false;
            }
            //If resizable determine what percent of drive partition was originally and match that to the new drive
            //while making sure the min size is still less than the resized size.
            else
            {
                partitionHelper.IsDynamicSize = true;
                if (partition.Type.ToLower() == "extended")
                {
                    partitionHelper.MinSizeBlk = extendedPartitionHelper.MinSizeBlk;
                }
                else if (partitionHelper.VolumeGroupHelper.Pv != null)
                {
                    partitionHelper.MinSizeBlk = partitionHelper.VolumeGroupHelper.MinSizeBlk;
                }
                else
                {
                    string imageFile = null;
                    foreach (var ext in new[] { "ntfs", "fat", "extfs", "hfsp", "imager", "winpe", "xfs" })
                    {
                        imageFile = new FilesystemServices().GetFileNameWithFullPath(_imageProfile.Image.Name,
                                                                                     hdNumberToGet.ToString(), partition.Number, ext);

                        if (!string.IsNullOrEmpty(imageFile))
                        {
                            break;
                        }
                    }
                    if (Path.GetExtension(imageFile) == ".wim")
                    {
                        partitionHelper.MinSizeBlk = partition.UsedMb * 1024 * 1024 / lbsByte;
                    }
                    else
                    {
                        //The resize value and used_mb value are calculated during upload by two different methods
                        //Use the one that is bigger just in case.
                        if (partition.VolumeSize > partition.UsedMb)
                        {
                            partitionHelper.MinSizeBlk = partition.VolumeSize * 1024 * 1024 / lbsByte;
                        }
                        else
                        {
                            partitionHelper.MinSizeBlk = partition.UsedMb * 1024 * 1024 / lbsByte;
                        }
                    }
                }
            }

            return(partitionHelper);
        }
Exemplo n.º 3
0
        /// <summary>
        ///     Calculates the minimum block size required for a single logical volume, assuming the logical volume cannot have any
        ///     children.
        /// </summary>
        public PartitionHelper LogicalVolume(LogicalVolume lv, int lbsByte, long newHdSize, int hdNumberToGet)
        {
            var logicalVolumeHelper = new PartitionHelper {
                MinSizeBlk = 0
            };

            if (lv.ForceFixedSize)
            {
                logicalVolumeHelper.MinSizeBlk    = lv.Size;
                logicalVolumeHelper.IsDynamicSize = false;
            }
            else if (!string.IsNullOrEmpty(lv.CustomSize) && !string.IsNullOrEmpty(lv.CustomSizeUnit))
            {
                long customSizeBytes = 0;
                switch (lv.CustomSizeUnit)
                {
                case "MB":
                    customSizeBytes = Convert.ToInt64(lv.CustomSize) * 1024 * 1024;
                    break;

                case "GB":
                    customSizeBytes = Convert.ToInt64(lv.CustomSize) * 1024 * 1024 * 1024;
                    break;

                case "%":
                    var hdPercent = Convert.ToDouble(lv.CustomSize) / 100;
                    customSizeBytes = Convert.ToInt64(hdPercent * newHdSize);
                    break;
                }
                logicalVolumeHelper.MinSizeBlk    = customSizeBytes / lbsByte;
                logicalVolumeHelper.IsDynamicSize = false;
            }
            else
            {
                logicalVolumeHelper.IsDynamicSize = true;
                string imageFile = null;
                foreach (var ext in new[] { "ntfs", "fat", "extfs", "hfsp", "imager", "xfs" })
                {
                    imageFile = new FilesystemServices().GetLVMFileNameWithFullPath(_imageProfile.Image.Name,
                                                                                    hdNumberToGet.ToString(), lv.VolumeGroup, lv.Name, ext);

                    if (!string.IsNullOrEmpty(imageFile))
                    {
                        break;
                    }
                }
                if (Path.GetExtension(imageFile) == ".wim")
                {
                    logicalVolumeHelper.MinSizeBlk = lv.UsedMb * 1024 * 1024 / lbsByte;
                }
                else
                {
                    if (lv.VolumeSize > lv.UsedMb)
                    {
                        logicalVolumeHelper.MinSizeBlk = lv.VolumeSize * 1024 * 1024 / lbsByte;
                    }
                    else
                    {
                        logicalVolumeHelper.MinSizeBlk = lv.UsedMb * 1024 * 1024 / lbsByte;
                    }
                }
            }

            return(logicalVolumeHelper);
        }
Exemplo n.º 4
0
        public List <PhysicalPartition> GetActivePartitions(int schemaHdNumber, ImageProfileWithImage imageProfile)
        {
            var listPhysicalPartition = new List <PhysicalPartition>();

            foreach (
                var partition in _imageSchema.HardDrives[schemaHdNumber].Partitions.Where(partition => partition.Active)
                )
            {
                var physicalPartition = new PhysicalPartition();
                physicalPartition.Number        = partition.Number;
                physicalPartition.Guid          = partition.Guid;
                physicalPartition.Uuid          = partition.Uuid;
                physicalPartition.FileSystem    = partition.FsType;
                physicalPartition.Type          = partition.Type;
                physicalPartition.EfiBootLoader = partition.EfiBootLoader;
                string imageFile = null;
                foreach (var ext in new[] { "ntfs", "fat", "extfs", "hfsp", "imager", "xfs" })
                {
                    imageFile = new FilesystemServices().GetFileNameWithFullPath(imageProfile.Image.Name,
                                                                                 schemaHdNumber.ToString(), partition.Number, ext);

                    if (!string.IsNullOrEmpty(imageFile))
                    {
                        physicalPartition.PartcloneFileSystem = ext;
                        break;
                    }
                }
                switch (Path.GetExtension(imageFile))
                {
                case ".lz4":
                    physicalPartition.Compression = "lz4";
                    physicalPartition.ImageType   = "Block";
                    break;

                case ".gz":
                    physicalPartition.Compression = "gz";
                    physicalPartition.ImageType   = "Block";
                    break;

                case ".uncp":
                    physicalPartition.Compression = "uncp";
                    physicalPartition.ImageType   = "Block";
                    break;

                case ".wim":
                    physicalPartition.ImageType = "File";
                    break;
                }

                if (partition.VolumeGroup.Name != null)
                {
                    physicalPartition.VolumeGroup      = new VolumeGroup();
                    physicalPartition.VolumeGroup.Name = partition.VolumeGroup.Name;
                    var listLogicalVolumes   = new List <Toems_Common.Dto.clientimaging.LogicalVolume>();
                    var logicalVolumeCounter = 0;
                    foreach (var logicalVolume in partition.VolumeGroup.LogicalVolumes.Where(x => x.Active))
                    {
                        logicalVolumeCounter++;
                        var clientLogicalVolume = new Toems_Common.Dto.clientimaging.LogicalVolume();
                        clientLogicalVolume.Name       = logicalVolume.Name;
                        clientLogicalVolume.FileSystem = logicalVolume.FsType;
                        clientLogicalVolume.Uuid       = logicalVolume.Uuid;

                        foreach (var ext in new[] { "ntfs", "fat", "extfs", "hfsp", "imager", "xfs" })
                        {
                            imageFile = new FilesystemServices().GetLVMFileNameWithFullPath(imageProfile.Image.Name,
                                                                                            schemaHdNumber.ToString(), partition.VolumeGroup.Name, logicalVolume.Name, ext);

                            if (!string.IsNullOrEmpty(imageFile))
                            {
                                clientLogicalVolume.PartcloneFileSystem = ext;
                                break;
                            }
                        }
                        switch (Path.GetExtension(imageFile))
                        {
                        case ".lz4":
                            clientLogicalVolume.Compression = "lz4";
                            clientLogicalVolume.ImageType   = "Block";
                            break;

                        case ".gz":
                            clientLogicalVolume.Compression = "gz";
                            clientLogicalVolume.ImageType   = "Block";
                            break;

                        case ".uncp":
                            clientLogicalVolume.Compression = "uncp";
                            clientLogicalVolume.ImageType   = "Block";
                            break;

                        case ".wim":
                            clientLogicalVolume.ImageType = "File";
                            break;
                        }

                        listLogicalVolumes.Add(clientLogicalVolume);
                    }
                    physicalPartition.VolumeGroup.LogicalVolumeCount = logicalVolumeCounter;
                    physicalPartition.VolumeGroup.LogicalVolumes     = listLogicalVolumes;
                }
                listPhysicalPartition.Add(physicalPartition);
            }

            return(listPhysicalPartition);
        }