Exemplo n.º 1
0
        private static void InitializeMaps()
        {
            Dictionary <string, VirtualDiskFactory> typeMap = new Dictionary <string, VirtualDiskFactory>();

            foreach (var type in typeof(VirtualDisk).Assembly.GetTypes())
            {
                VirtualDiskFactoryAttribute attr = (VirtualDiskFactoryAttribute)Attribute.GetCustomAttribute(type, typeof(VirtualDiskFactoryAttribute), false);
                if (attr != null)
                {
                    VirtualDiskFactory factory = (VirtualDiskFactory)Activator.CreateInstance(type);
                    typeMap.Add(attr.Type, factory);
                }
            }

            s_typeMap = typeMap;
        }
        /// <summary>
        /// Create a new virtual disk.
        /// </summary>
        /// <param name="type">The type of disk to create (see <see cref="SupportedDiskTypes"/>).</param>
        /// <param name="variant">The variant of the type to create (see <see cref="GetSupportedDiskVariants"/>).</param>
        /// <param name="path">The path (or URI) for the disk to create.</param>
        /// <param name="diskParameters">Parameters controlling the capacity, geometry, etc of the new disk.</param>
        /// <param name="user">The user identity to use when accessing the <c>path</c> (or null).</param>
        /// <param name="password">The password to use when accessing the <c>path</c> (or null).</param>
        /// <returns>The newly created disk.</returns>
        public static VirtualDisk CreateDisk(string type, string variant, string path, VirtualDiskParameters diskParameters, string user, string password)
        {
            Uri         uri    = PathToUri(path);
            VirtualDisk result = null;

            Type transportType;

            if (!VirtualDiskManager.DiskTransports.TryGetValue(uri.Scheme.ToUpperInvariant(), out transportType))
            {
                throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture, "Unable to parse path '{0}'", path), path);
            }

            VirtualDiskTransport transport = (VirtualDiskTransport)Activator.CreateInstance(transportType);

            try
            {
                transport.Connect(uri, user, password);

                if (transport.IsRawDisk)
                {
                    result = transport.OpenDisk(FileAccess.ReadWrite);
                }
                else
                {
                    VirtualDiskFactory factory = VirtualDiskManager.TypeMap[type];

                    result = factory.CreateDisk(transport.GetFileLocator(), variant.ToLowerInvariant(), Utilities.GetFileFromPath(path), diskParameters);
                }

                if (result != null)
                {
                    result._transport = transport;
                    transport         = null;
                }

                return(result);
            }
            finally
            {
                if (transport != null)
                {
                    transport.Dispose();
                }
            }
        }
Exemplo n.º 3
0
        /// <summary>
        /// Create a new virtual disk.
        /// </summary>
        /// <param name="type">The type of disk to create (see <see cref="SupportedDiskTypes"/>)</param>
        /// <param name="variant">The variant of the type to create (see <see cref="GetSupportedDiskVariants"/>)</param>
        /// <param name="path">The path (or URI) for the disk to create</param>
        /// <param name="capacity">The capacity of the new disk</param>
        /// <param name="geometry">The geometry of the new disk (or null).</param>
        /// <param name="user">The user identity to use when accessing the <c>path</c> (or null)</param>
        /// <param name="password">The password to use when accessing the <c>path</c> (or null)</param>
        /// <param name="parameters">Untyped parameters controlling the creation process (TBD)</param>
        /// <returns>The newly created disk</returns>
        public static VirtualDisk CreateDisk(string type, string variant, string path, long capacity, Geometry geometry, string user, string password, Dictionary <string, string> parameters)
        {
            Uri         uri    = PathToUri(path);
            VirtualDisk result = null;

            VirtualDiskTransport transport;

            if (!DiskTransports.TryGetValue(uri.Scheme.ToUpperInvariant(), out transport))
            {
                throw new FileNotFoundException(string.Format(CultureInfo.InvariantCulture, "Unable to parse path '{0}'", path), path);
            }

            try
            {
                transport.Connect(uri, user, password);

                if (transport.IsRawDisk)
                {
                    result = transport.OpenDisk(FileAccess.ReadWrite);
                }
                else
                {
                    VirtualDiskFactory factory = TypeMap[type];

                    result = factory.CreateDisk(transport.GetFileLocator(), variant.ToLowerInvariant(), Utilities.GetFileFromPath(path), capacity, geometry, parameters ?? new Dictionary <string, string>());
                }

                if (result != null)
                {
                    result._transport = transport;
                    transport         = null;
                }

                return(result);
            }
            finally
            {
                if (transport != null)
                {
                    transport.Dispose();
                }
            }
        }
        /// <summary>
        /// Create a new virtual disk, possibly within an existing disk.
        /// </summary>
        /// <param name="fileSystem">The file system to create the disk on.</param>
        /// <param name="type">The type of disk to create (see <see cref="SupportedDiskTypes"/>).</param>
        /// <param name="variant">The variant of the type to create (see <see cref="GetSupportedDiskVariants"/>).</param>
        /// <param name="path">The path (or URI) for the disk to create.</param>
        /// <param name="capacity">The capacity of the new disk.</param>
        /// <param name="geometry">The geometry of the new disk (or null).</param>
        /// <param name="parameters">Untyped parameters controlling the creation process (TBD).</param>
        /// <returns>The newly created disk.</returns>
        public static VirtualDisk CreateDisk(DiscFileSystem fileSystem, string type, string variant, string path, long capacity, Geometry geometry, Dictionary <string, string> parameters)
        {
            VirtualDiskFactory factory = VirtualDiskManager.TypeMap[type];

            VirtualDiskParameters diskParams = new VirtualDiskParameters
            {
                AdapterType = GenericDiskAdapterType.Scsi,
                Capacity    = capacity,
                Geometry    = geometry
            };

            if (parameters != null)
            {
                foreach (string key in parameters.Keys)
                {
                    diskParams.ExtendedParameters[key] = parameters[key];
                }
            }

            return(factory.CreateDisk(new DiscFileLocator(fileSystem, Utilities.GetDirectoryFromPath(path)), variant.ToLowerInvariant(), Utilities.GetFileFromPath(path), diskParams));
        }
Exemplo n.º 5
0
        private static void InitializeMaps()
        {
            Dictionary <string, VirtualDiskFactory> typeMap      = new Dictionary <string, VirtualDiskFactory>();
            Dictionary <string, VirtualDiskFactory> extensionMap = new Dictionary <string, VirtualDiskFactory>();

            foreach (var type in typeof(VirtualDisk).Assembly.GetTypes())
            {
                VirtualDiskFactoryAttribute attr = (VirtualDiskFactoryAttribute)Attribute.GetCustomAttribute(type, typeof(VirtualDiskFactoryAttribute), false);
                if (attr != null)
                {
                    VirtualDiskFactory factory = (VirtualDiskFactory)Activator.CreateInstance(type);
                    typeMap.Add(attr.Type, factory);
                    foreach (var extension in attr.FileExtensions)
                    {
                        extensionMap.Add(extension.ToUpperInvariant(), factory);
                    }
                }
            }

            s_typeMap      = typeMap;
            s_extensionMap = extensionMap;
        }
Exemplo n.º 6
0
        /// <summary>
        /// Locates VirtualDiskFactory factories attributed with VirtualDiskFactoryAttribute, and types marked with VirtualDiskTransportAttribute, that are able to work with Virtual Disk types.
        /// </summary>
        /// <param name="assembly">An assembly to scan</param>
        public static void RegisterVirtualDiskTypes(Assembly assembly)
        {
            foreach (Type type in assembly.GetTypes())
            {
                VirtualDiskFactoryAttribute diskFactoryAttribute = (VirtualDiskFactoryAttribute)ReflectionHelper.GetCustomAttribute(type, typeof(VirtualDiskFactoryAttribute), false);
                if (diskFactoryAttribute != null)
                {
                    VirtualDiskFactory factory = (VirtualDiskFactory)Activator.CreateInstance(type);
                    TypeMap.Add(diskFactoryAttribute.Type, factory);

                    foreach (string extension in diskFactoryAttribute.FileExtensions)
                    {
                        ExtensionMap.Add(extension.ToUpperInvariant(), factory);
                    }
                }

                VirtualDiskTransportAttribute diskTransportAttribute = ReflectionHelper.GetCustomAttribute(type, typeof(VirtualDiskTransportAttribute), false) as VirtualDiskTransportAttribute;
                if (diskTransportAttribute != null)
                {
                    DiskTransports.Add(diskTransportAttribute.Scheme.ToUpperInvariant(), type);
                }
            }
        }
Exemplo n.º 7
0
        /// <summary>
        /// Create a new virtual disk, possibly within an existing disk.
        /// </summary>
        /// <param name="fileSystem">The file system to create the disk on</param>
        /// <param name="type">The type of disk to create (see <see cref="SupportedDiskTypes"/>)</param>
        /// <param name="variant">The variant of the type to create (see <see cref="GetSupportedDiskVariants"/>)</param>
        /// <param name="path">The path (or URI) for the disk to create</param>
        /// <param name="capacity">The capacity of the new disk</param>
        /// <param name="geometry">The geometry of the new disk (or null).</param>
        /// <param name="parameters">Untyped parameters controlling the creation process (TBD)</param>
        /// <returns>The newly created disk</returns>
        public static VirtualDisk CreateDisk(DiscFileSystem fileSystem, string type, string variant, string path, long capacity, Geometry geometry, Dictionary <string, string> parameters)
        {
            VirtualDiskFactory factory = TypeMap[type];

            return(factory.CreateDisk(new DiscFileLocator(fileSystem, Utilities.GetDirectoryFromPath(path)), variant.ToLowerInvariant(), Utilities.GetFileFromPath(path), capacity, geometry, parameters ?? new Dictionary <string, string>()));
        }