VirtualBox

source: vbox/trunk/src/VBox/Main/include/ApplianceImpl.h@ 48431

Last change on this file since 48431 was 47716, checked in by vboxsync, 11 years ago

pr6022. 3rd variant (using VFS streaming feature) of GZIP support for reading the gzipped storage images from OVA/OVF package has been added.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 13.4 KB
Line 
1/* $Id: ApplianceImpl.h 47716 2013-08-14 05:33:22Z vboxsync $ */
2
3/** @file
4 *
5 * VirtualBox COM class implementation
6 */
7
8/*
9 * Copyright (C) 2006-2012 Oracle Corporation
10 *
11 * This file is part of VirtualBox Open Source Edition (OSE), as
12 * available from http://www.virtualbox.org. This file is free software;
13 * you can redistribute it and/or modify it under the terms of the GNU
14 * General Public License (GPL) as published by the Free Software
15 * Foundation, in version 2 as it comes in the "COPYING" file of the
16 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
17 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
18 */
19
20#ifndef ____H_APPLIANCEIMPL
21#define ____H_APPLIANCEIMPL
22
23/* VBox includes */
24#include "VirtualBoxBase.h"
25
26/* Todo: This file needs massive cleanup. Split IAppliance in a public and
27 * private classes. */
28#include <iprt/tar.h>
29#include <iprt/circbuf.h>
30#include <VBox/vd.h>
31#include <iprt/sha.h>
32
33#include "ovfreader.h"
34#include <set>
35
36/* VBox forward declarations */
37class Progress;
38class VirtualSystemDescription;
39struct VirtualSystemDescriptionEntry;
40struct LocationInfo;
41typedef struct VDINTERFACE *PVDINTERFACE;
42typedef struct VDINTERFACEIO *PVDINTERFACEIO;
43typedef struct SHASTORAGE *PSHASTORAGE;
44
45typedef enum applianceIOName { applianceIOTar, applianceIOFile, applianceIOSha } APPLIANCEIONAME;
46
47namespace ovf
48{
49 struct HardDiskController;
50 struct VirtualSystem;
51 class OVFReader;
52 struct DiskImage;
53 struct EnvelopeData;
54}
55
56namespace xml
57{
58 class Document;
59 class ElementNode;
60}
61
62namespace settings
63{
64 class MachineConfigFile;
65}
66
67class ATL_NO_VTABLE Appliance :
68 public VirtualBoxBase,
69 VBOX_SCRIPTABLE_IMPL(IAppliance)
70{
71public:
72 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(Appliance, IAppliance)
73
74 DECLARE_NOT_AGGREGATABLE(Appliance)
75
76 DECLARE_PROTECT_FINAL_CONSTRUCT()
77
78 BEGIN_COM_MAP(Appliance)
79 VBOX_DEFAULT_INTERFACE_ENTRIES(IAppliance)
80 END_COM_MAP()
81
82 DECLARE_EMPTY_CTOR_DTOR (Appliance)
83
84
85
86 // public initializer/uninitializer for internal purposes only
87 HRESULT FinalConstruct() { return BaseFinalConstruct(); }
88 void FinalRelease() { uninit(); BaseFinalRelease(); }
89
90 HRESULT init(VirtualBox *aVirtualBox);
91 void uninit();
92
93 /* IAppliance properties */
94 STDMETHOD(COMGETTER(Path))(BSTR *aPath);
95 STDMETHOD(COMGETTER(Disks))(ComSafeArrayOut(BSTR, aDisks));
96 STDMETHOD(COMGETTER(VirtualSystemDescriptions))(ComSafeArrayOut(IVirtualSystemDescription*, aVirtualSystemDescriptions));
97 STDMETHOD(COMGETTER(Machines))(ComSafeArrayOut(BSTR, aMachines));
98
99 /* IAppliance methods */
100 /* Import methods */
101 STDMETHOD(Read)(IN_BSTR path, IProgress **aProgress);
102 STDMETHOD(Interpret)(void);
103 STDMETHOD(ImportMachines)(ComSafeArrayIn(ImportOptions_T, options), IProgress **aProgress);
104 /* Export methods */
105 STDMETHOD(CreateVFSExplorer)(IN_BSTR aURI, IVFSExplorer **aExplorer);
106 STDMETHOD(Write)(IN_BSTR format, BOOL fManifest, IN_BSTR path, IProgress **aProgress);
107
108 STDMETHOD(GetWarnings)(ComSafeArrayOut(BSTR, aWarnings));
109
110 /* public methods only for internal purposes */
111
112 static HRESULT setErrorStatic(HRESULT aResultCode,
113 const Utf8Str &aText)
114 {
115 return setErrorInternal(aResultCode, getStaticClassIID(), getStaticComponentName(), aText, false, true);
116 }
117
118 /* private instance data */
119private:
120 /** weak VirtualBox parent */
121 VirtualBox* const mVirtualBox;
122
123 struct ImportStack;
124 struct TaskOVF;
125 struct Data; // opaque, defined in ApplianceImpl.cpp
126 Data *m;
127
128 enum SetUpProgressMode { ImportFile, ImportS3, WriteFile, WriteS3 };
129
130 /*******************************************************************************
131 * General stuff
132 ******************************************************************************/
133
134 bool isApplianceIdle();
135 HRESULT searchUniqueVMName(Utf8Str& aName) const;
136 HRESULT searchUniqueDiskImageFilePath(Utf8Str& aName) const;
137 HRESULT setUpProgress(ComObjPtr<Progress> &pProgress,
138 const Bstr &bstrDescription,
139 SetUpProgressMode mode);
140 void waitForAsyncProgress(ComObjPtr<Progress> &pProgressThis, ComPtr<IProgress> &pProgressAsync);
141 void addWarning(const char* aWarning, ...);
142 void disksWeight();
143 void parseBucket(Utf8Str &aPath, Utf8Str &aBucket);
144
145 static DECLCALLBACK(int) taskThreadImportOrExport(RTTHREAD aThread, void *pvUser);
146
147 HRESULT initSetOfSupportedStandardsURI();
148
149 Utf8Str typeOfVirtualDiskFormatFromURI(Utf8Str type) const;
150
151 std::set<Utf8Str> URIFromTypeOfVirtualDiskFormat(Utf8Str type);
152
153 HRESULT initApplianceIONameMap();
154
155 Utf8Str applianceIOName(APPLIANCEIONAME type) const;
156
157 /*******************************************************************************
158 * Read stuff
159 ******************************************************************************/
160
161 HRESULT readImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
162
163 HRESULT readFS(TaskOVF *pTask);
164 HRESULT readFSOVF(TaskOVF *pTask);
165 HRESULT readFSOVA(TaskOVF *pTask);
166 HRESULT readFSImpl(TaskOVF *pTask, const RTCString &strFilename, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage);
167 HRESULT readS3(TaskOVF *pTask);
168
169 /*******************************************************************************
170 * Import stuff
171 ******************************************************************************/
172
173 HRESULT importImpl(const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
174
175 HRESULT importFS(TaskOVF *pTask);
176 HRESULT importFSOVF(TaskOVF *pTask, AutoWriteLockBase& writeLock);
177 HRESULT importFSOVA(TaskOVF *pTask, AutoWriteLockBase& writeLock);
178 HRESULT importS3(TaskOVF *pTask);
179
180 HRESULT readFileToBuf(const Utf8Str &strFile,
181 void **ppvBuf,
182 size_t *pcbSize,
183 bool fCreateDigest,
184 PVDINTERFACEIO pCallbacks,
185 PSHASTORAGE pStorage);
186 HRESULT readTarFileToBuf(RTTAR tar,
187 const Utf8Str &strFile,
188 void **ppvBuf,
189 size_t *pcbSize,
190 bool fCreateDigest,
191 PVDINTERFACEIO pCallbacks,
192 PSHASTORAGE pStorage);
193 HRESULT verifyManifestFile(const Utf8Str &strFile, ImportStack &stack, void *pvBuf, size_t cbSize);
194
195 void convertDiskAttachmentValues(const ovf::HardDiskController &hdc,
196 uint32_t ulAddressOnParent,
197 Bstr &controllerType,
198 int32_t &lControllerPort,
199 int32_t &lDevice);
200
201 void importOneDiskImage(const ovf::DiskImage &di,
202 Utf8Str *strTargetPath,
203 ComObjPtr<Medium> &pTargetHD,
204 ImportStack &stack,
205 PVDINTERFACEIO pCallbacks,
206 PSHASTORAGE pStorage);
207
208 void importMachineGeneric(const ovf::VirtualSystem &vsysThis,
209 ComObjPtr<VirtualSystemDescription> &vsdescThis,
210 ComPtr<IMachine> &pNewMachine,
211 ImportStack &stack,
212 PVDINTERFACEIO pCallbacks,
213 PSHASTORAGE pStorage);
214 void importVBoxMachine(ComObjPtr<VirtualSystemDescription> &vsdescThis,
215 ComPtr<IMachine> &pNewMachine,
216 ImportStack &stack,
217 PVDINTERFACEIO pCallbacks,
218 PSHASTORAGE pStorage);
219 void importMachines(ImportStack &stack,
220 PVDINTERFACEIO pCallbacks,
221 PSHASTORAGE pStorage);
222
223 /*******************************************************************************
224 * Write stuff
225 ******************************************************************************/
226
227 HRESULT writeImpl(ovf::OVFVersion_T aFormat, const LocationInfo &aLocInfo, ComObjPtr<Progress> &aProgress);
228
229 HRESULT writeFS(TaskOVF *pTask);
230 HRESULT writeFSOVF(TaskOVF *pTask, AutoWriteLockBase& writeLock);
231 HRESULT writeFSOVA(TaskOVF *pTask, AutoWriteLockBase& writeLock);
232 HRESULT writeFSImpl(TaskOVF *pTask, AutoWriteLockBase& writeLock, PVDINTERFACEIO pCallbacks, PSHASTORAGE pStorage);
233 HRESULT writeS3(TaskOVF *pTask);
234
235 struct XMLStack;
236
237 void buildXML(AutoWriteLockBase& writeLock,
238 xml::Document &doc,
239 XMLStack &stack,
240 const Utf8Str &strPath,
241 ovf::OVFVersion_T enFormat);
242 void buildXMLForOneVirtualSystem(AutoWriteLockBase& writeLock,
243 xml::ElementNode &elmToAddVirtualSystemsTo,
244 std::list<xml::ElementNode*> *pllElementsWithUuidAttributes,
245 ComObjPtr<VirtualSystemDescription> &vsdescThis,
246 ovf::OVFVersion_T enFormat,
247 XMLStack &stack);
248
249 HRESULT preCheckImageAvailability(PSHASTORAGE pSHAStorage,
250 RTCString &availableImage);
251
252 friend class Machine;
253};
254
255void parseURI(Utf8Str strUri, LocationInfo &locInfo);
256
257struct VirtualSystemDescriptionEntry
258{
259 uint32_t ulIndex; // zero-based index of this entry within array
260 VirtualSystemDescriptionType_T type; // type of this entry
261 Utf8Str strRef; // reference number (hard disk controllers only)
262 Utf8Str strOvf; // original OVF value (type-dependent)
263 Utf8Str strVboxSuggested; // configuration value (type-dependent); original value suggested by interpret()
264 Utf8Str strVboxCurrent; // configuration value (type-dependent); current value, either from interpret() or setFinalValue()
265 Utf8Str strExtraConfigSuggested; // extra configuration key=value strings (type-dependent); original value suggested by interpret()
266 Utf8Str strExtraConfigCurrent; // extra configuration key=value strings (type-dependent); current value, either from interpret() or setFinalValue()
267
268 uint32_t ulSizeMB; // hard disk images only: a copy of ovf::DiskImage::ulSuggestedSizeMB
269};
270
271class ATL_NO_VTABLE VirtualSystemDescription :
272 public VirtualBoxBase,
273 VBOX_SCRIPTABLE_IMPL(IVirtualSystemDescription)
274{
275 friend class Appliance;
276
277public:
278 VIRTUALBOXBASE_ADD_ERRORINFO_SUPPORT(VirtualSystemDescription, IVirtualSystemDescription)
279
280 DECLARE_NOT_AGGREGATABLE(VirtualSystemDescription)
281
282 DECLARE_PROTECT_FINAL_CONSTRUCT()
283
284 BEGIN_COM_MAP(VirtualSystemDescription)
285 VBOX_DEFAULT_INTERFACE_ENTRIES(IVirtualSystemDescription)
286 END_COM_MAP()
287
288 DECLARE_EMPTY_CTOR_DTOR (VirtualSystemDescription)
289
290 // public initializer/uninitializer for internal purposes only
291 HRESULT FinalConstruct() { return BaseFinalConstruct(); }
292 void FinalRelease() { uninit(); BaseFinalRelease(); }
293
294 HRESULT init();
295 void uninit();
296
297 /* IVirtualSystemDescription properties */
298 STDMETHOD(COMGETTER(Count))(ULONG *aCount);
299
300 /* IVirtualSystemDescription methods */
301 STDMETHOD(GetDescription)(ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
302 ComSafeArrayOut(BSTR, aRefs),
303 ComSafeArrayOut(BSTR, aOvfValues),
304 ComSafeArrayOut(BSTR, aVboxValues),
305 ComSafeArrayOut(BSTR, aExtraConfigValues));
306
307 STDMETHOD(GetDescriptionByType)(VirtualSystemDescriptionType_T aType,
308 ComSafeArrayOut(VirtualSystemDescriptionType_T, aTypes),
309 ComSafeArrayOut(BSTR, aRefs),
310 ComSafeArrayOut(BSTR, aOvfValues),
311 ComSafeArrayOut(BSTR, aVboxValues),
312 ComSafeArrayOut(BSTR, aExtraConfigValues));
313
314 STDMETHOD(GetValuesByType)(VirtualSystemDescriptionType_T aType,
315 VirtualSystemDescriptionValueType_T aWhich,
316 ComSafeArrayOut(BSTR, aValues));
317
318 STDMETHOD(SetFinalValues)(ComSafeArrayIn(BOOL, aEnabled),
319 ComSafeArrayIn(IN_BSTR, aVboxValues),
320 ComSafeArrayIn(IN_BSTR, aExtraConfigValues));
321
322 STDMETHOD(AddDescription)(VirtualSystemDescriptionType_T aType,
323 IN_BSTR aVboxValue,
324 IN_BSTR aExtraConfigValue);
325
326 /* public methods only for internal purposes */
327
328 void addEntry(VirtualSystemDescriptionType_T aType,
329 const Utf8Str &strRef,
330 const Utf8Str &aOvfValue,
331 const Utf8Str &aVboxValue,
332 uint32_t ulSizeMB = 0,
333 const Utf8Str &strExtraConfig = "");
334
335 std::list<VirtualSystemDescriptionEntry*> findByType(VirtualSystemDescriptionType_T aType);
336 const VirtualSystemDescriptionEntry* findControllerFromID(uint32_t id);
337
338 void importVboxMachineXML(const xml::ElementNode &elmMachine);
339 const settings::MachineConfigFile* getMachineConfig() const;
340
341 /* private instance data */
342private:
343 struct Data;
344 Data *m;
345
346 friend class Machine;
347};
348
349#endif // ____H_APPLIANCEIMPL
350/* vi: set tabstop=4 shiftwidth=4 expandtab: */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette