Changeset 2904 for box/trunk/bin

Timestamp:

08/04/2011 21:01:01 (14 months ago)

Author:

chris

Message:

Actually create a VSS snapshot.

Clean up writer metadata and writer status after use.

Location:

box/trunk/bin/bbackupd

Files:

• BackupDaemon.cpp (modified) (17 diffs)
• BackupDaemon.h (modified) (1 diff)

box/trunk/bin/bbackupd/BackupDaemon.cpp

@@ -120 +120 @@
                 {
                         char* pStr = ConvertFromWideString(buf, CP_UTF8);
+                        
+                        if(pStr == NULL)
+                        {
+                                return "conversion failed";
+                        }
+                        
                         std::string result(pStr);
                         free(pStr);
@@ -132 +138 @@
                 }
 
-                std::ostream& operator<< (std::ostream& o, const BSTR arg)
+                std::string BstrToString(const BSTR arg)
                 {
                         if(arg == NULL)
                         {
-                                o << "(null)";
+                                return std::string("(null)");
                         }
                         else
                         {
                                 // Extract the *long* before where the arg points to
-                                long len = ((long *)arg)[-1];
+                                long len = ((long *)arg)[-1] / 2;
                                 std::wstring wstr((WCHAR *)arg, len);
                                 std::string str;
@@ -148 +154 @@
                                         throw std::exception("string conversion failed");
                                 }
-                                o << str;
-                        }
-
-                        return o;
+                                return str;
+                        }
                 }
 #       endif
@@ -1069 +1073 @@
 }
 
+#define CALL_MEMBER_FN(object, method) ((object).*(method))
+
+bool BackupDaemon::CallAndWaitForAsync(AsyncMethod method,
+        const std::string& description)
+{
+        IVssAsync *pAsync;
+        HRESULT result = CALL_MEMBER_FN(*mpVssBackupComponents, method)(&pAsync);
+        if(result != S_OK)
+        {
+                BOX_ERROR("VSS: " << description << " failed: " <<
+                        GetMsgForHresult(result));
+                return false;
+        }
+
+        return WaitForAsync(pAsync, description);
+}
+
 void BackupDaemon::CreateVssBackupComponents()
 {
@@ -1131 +1152 @@
         }
 
-        {
-                IVssAsync *pAsync;
-                result = mpVssBackupComponents->GatherWriterMetadata(&pAsync);
-                if(result != S_OK)
-                {
-                        BOX_ERROR("VSS: Failed to set backup state: " <<
-                                GetMsgForHresult(result));
-                        goto CreateVssBackupComponents_cleanup_mpVssBackupComponents;
-                }
-
-                if(!WaitForAsync(pAsync, "GatherWriterMetadata()"))
-                {
-                        goto CreateVssBackupComponents_cleanup_mpVssBackupComponents;
-                }
+        if(!CallAndWaitForAsync(&IVssBackupComponents::GatherWriterMetadata,
+                "GatherWriterMetadata()"))
+        {
+                goto CreateVssBackupComponents_cleanup_WriterMetadata;
         }
 
@@ -1153 +1164 @@
                 BOX_ERROR("VSS: Failed to get writer count: " <<
                         GetMsgForHresult(result));
-                goto CreateVssBackupComponents_cleanup_mpVssBackupComponents;
+                goto CreateVssBackupComponents_cleanup_WriterMetadata;
         }
 
@@ -1167 +1178 @@
                         BOX_ERROR("Failed to get VSS metadata from writer " << iWriter <<
                                 ": " << GetMsgForHresult(result));
-                        goto CreateVssBackupComponents_cleanup_mpVssBackupComponents;
+                        goto CreateVssBackupComponents_cleanup_WriterMetadata;
                 }
 
@@ -1175 +1186 @@
                 if(result != S_OK)
                 {
-                        BOX_ERROR("Failed to get VSS metadata file counts from "
+                        BOX_ERROR("VSS: Failed to get metadata file counts from "
                                 "writer " << iWriter << ": " << 
                                 GetMsgForHresult(result));
@@ -1188 +1199 @@
                         if(result != S_OK)
                         {
-                                BOX_ERROR("Failed to get VSS metadata component " <<
+                                BOX_ERROR("VSS: Failed to get metadata component " <<
                                         iComponent << " from writer " << iWriter << ": " << 
                                         GetMsgForHresult(result));
@@ -1198 +1209 @@
                         if(result != S_OK)
                         {
-                                BOX_ERROR("Failed to get VSS metadata component " <<
+                                BOX_ERROR("VSS: Failed to get metadata component " <<
                                         iComponent << " info from writer " << iWriter << ": " << 
                                         GetMsgForHresult(result));
@@ -1217 +1228 @@
 
                         BOX_INFO("VSS: logical path: " << 
-                                pComponentInfo->bstrLogicalPath);
+                                BstrToString(pComponentInfo->bstrLogicalPath));
                         BOX_INFO("VSS: component name: " << 
-                                pComponentInfo->bstrComponentName);
+                                BstrToString(pComponentInfo->bstrComponentName));
                         BOX_INFO("VSS: caption: " << 
-                                pComponentInfo->bstrCaption);
+                                BstrToString(pComponentInfo->bstrCaption));
                         BOX_INFO("VSS: restore metadata: " << 
                                 pComponentInfo->bRestoreMetadata);
@@ -1254 +1265 @@
                 BOX_ERROR("VSS: Failed to start snapshot set: " <<
                         GetMsgForHresult(result));
-                goto CreateVssBackupComponents_cleanup_mpVssBackupComponents;
+                goto CreateVssBackupComponents_cleanup_WriterMetadata;
         }
 
@@ -1293 +1304 @@
                                                 volumeRoot << " to snapshot set: " <<
                                                 GetMsgForHresult(result));
-                                        goto CreateVssBackupComponents_cleanup_mpVssBackupComponents;
+                                        goto CreateVssBackupComponents_cleanup_WriterMetadata;
                                 }
                         }
@@ -1309 +1320 @@
         }
 
-        {
-                IVssAsync *pAsync;
-                result = mpVssBackupComponents->PrepareForBackup(&pAsync);
+        if(!CallAndWaitForAsync(&IVssBackupComponents::PrepareForBackup,
+                "PrepareForBackup()"))
+        {
+                goto CreateVssBackupComponents_cleanup_WriterMetadata;
+        }
+
+        if(!CallAndWaitForAsync(&IVssBackupComponents::DoSnapshotSet,
+                "DoSnapshotSet()"))
+        {
+                goto CreateVssBackupComponents_cleanup_WriterMetadata;
+        }
+
+        if(!CallAndWaitForAsync(&IVssBackupComponents::GatherWriterStatus,
+                "GatherWriterStatus()"))
+        {
+                goto CreateVssBackupComponents_cleanup_WriterStatus;
+        }
+
+        result = mpVssBackupComponents->GetWriterStatusCount(&writerCount);
+        if(result != S_OK)
+        {
+                BOX_ERROR("VSS: Failed to get writer status count: " << 
+                        GetMsgForHresult(result));
+                goto CreateVssBackupComponents_cleanup_WriterStatus;
+        }
+
+        for(UINT iWriter = 0; iWriter < writerCount; iWriter++)
+        {
+                VSS_ID instance, writer;
+                BSTR writerNameBstr;
+                VSS_WRITER_STATE writerState;
+                HRESULT writerResult;
+
+                result = mpVssBackupComponents->GetWriterStatus(iWriter,
+                        &instance, &writer, &writerNameBstr, &writerState,
+                        &writerResult);
                 if(result != S_OK)
                 {
-                        BOX_ERROR("VSS: Failed to prepare for backup: " <<
-                                GetMsgForHresult(result));
-                        goto CreateVssBackupComponents_cleanup_mpVssBackupComponents;
-                }
-
-                if(!WaitForAsync(pAsync, "PrepareForBackup()"))
-                {
-                        goto CreateVssBackupComponents_cleanup_mpVssBackupComponents;
-                }
+                        BOX_ERROR("VSS: Failed to query writer " << iWriter <<
+                                " status: " << GetMsgForHresult(result));
+                        goto CreateVssBackupComponents_cleanup_WriterStatus;
+                }
+
+                std::string writerName = BstrToString(writerNameBstr);
+                ::SysFreeString(writerNameBstr);
+
+                if(writerResult != S_OK)
+                {
+                        BOX_ERROR("VSS: Writer " << iWriter << " (" <<
+                                writerName << ") failed: " <<
+                                GetMsgForHresult(writerResult));
+                        continue;
+                }
+
+                std::string stateName;
+
+                switch(writerState)
+                {
+#define WRITER_STATE(code) \
+                case code: stateName = #code; break;
+                WRITER_STATE(VSS_WS_UNKNOWN);
+                WRITER_STATE(VSS_WS_STABLE);
+                WRITER_STATE(VSS_WS_WAITING_FOR_FREEZE);
+                WRITER_STATE(VSS_WS_WAITING_FOR_THAW);
+                WRITER_STATE(VSS_WS_WAITING_FOR_POST_SNAPSHOT);
+                WRITER_STATE(VSS_WS_WAITING_FOR_BACKUP_COMPLETE);
+                WRITER_STATE(VSS_WS_FAILED_AT_IDENTIFY);
+                WRITER_STATE(VSS_WS_FAILED_AT_PREPARE_BACKUP);
+                WRITER_STATE(VSS_WS_FAILED_AT_PREPARE_SNAPSHOT);
+                WRITER_STATE(VSS_WS_FAILED_AT_FREEZE);
+                WRITER_STATE(VSS_WS_FAILED_AT_THAW);
+                WRITER_STATE(VSS_WS_FAILED_AT_POST_SNAPSHOT);
+                WRITER_STATE(VSS_WS_FAILED_AT_BACKUP_COMPLETE);
+                WRITER_STATE(VSS_WS_FAILED_AT_PRE_RESTORE);
+                WRITER_STATE(VSS_WS_FAILED_AT_POST_RESTORE);
+                WRITER_STATE(VSS_WS_FAILED_AT_BACKUPSHUTDOWN);
+#undef WRITER_STATE
+                default:
+                        std::ostringstream o;
+                        o << "unknown (" << writerState << ")";
+                        stateName = o.str();
+                }
+
+                BOX_INFO("VSS: Writer " << iWriter << " (" <<
+                        writerName << ") is in state " << stateName);
         }
 
@@ -1330 +1412 @@
         if(result != S_OK)
         {
-                BOX_ERROR("Failed to query VSS snapshot list: " << 
+                BOX_ERROR("VSS: Failed to query snapshot list: " << 
                         GetMsgForHresult(result));
-                goto CreateVssBackupComponents_cleanup_mpVssBackupComponents;
+                goto CreateVssBackupComponents_cleanup_WriterStatus;
         }
 
@@ -1343 +1425 @@
                 if(result != S_OK && result != S_FALSE)
                 {
-                        BOX_ERROR("Failed to enumerate VSS snapshot: " << 
+                        BOX_ERROR("VSS: Failed to enumerate snapshot: " << 
                                 GetMsgForHresult(result));
                 }
                 else if(count != 1)
                 {
-                        BOX_ERROR("Failed to enumerate VSS snapshot: " <<
+                        BOX_ERROR("VSS: Failed to enumerate snapshot: " <<
                                 "Next() returned " << count << " objects instead of 1");
                 }
                 else if(rgelt.Type != VSS_OBJECT_SNAPSHOT)
                 {
-                        BOX_ERROR("Failed to enumerate VSS snapshot: " <<
+                        BOX_ERROR("VSS: Failed to enumerate snapshot: " <<
                                 "Next() returned a type " << rgelt.Type << " object "
                                 "instead of VSS_OBJECT_SNAPSHOT");
@@ -1422 +1504 @@
 
         pEnum->Release();
+
+CreateVssBackupComponents_cleanup_WriterStatus:
+        result = mpVssBackupComponents->FreeWriterStatus();
+        if(result != S_OK)
+        {
+                BOX_ERROR("VSS: Failed to free writer status: " <<
+                        GetMsgForHresult(result));
+        }
+
+CreateVssBackupComponents_cleanup_WriterMetadata:
+        result = mpVssBackupComponents->FreeWriterMetadata();
+        if(result != S_OK)
+        {
+                BOX_ERROR("VSS: Failed to free writer metadata: " <<
+                        GetMsgForHresult(result));
+        }
 
 CreateVssBackupComponents_cleanup_mpVssBackupComponents:

box/trunk/bin/bbackupd/BackupDaemon.h

@@ -533 +533 @@
         void CreateVssBackupComponents();
         bool WaitForAsync(IVssAsync *pAsync, const std::string& description);
+        typedef HRESULT (__stdcall IVssBackupComponents::*AsyncMethod)(IVssAsync**);
+        bool CallAndWaitForAsync(AsyncMethod method,
+                const std::string& description);
 #endif
 };