New upstream version 8.1.0

fsck/source/toolkit/DatabaseTk.cpp

@@ -0,0 +1,273 @@
+#include "DatabaseTk.h"
+
+#include <common/app/log/LogContext.h>
+#include <common/storage/striping/Raid0Pattern.h>
+#include <common/toolkit/FsckTk.h>
+#include <common/toolkit/StringTk.h>
+#include <database/FsckDB.h>
+#include <database/FsckDBTable.h>
+#include <common/storage/Path.h>
+#include <common/toolkit/StorageTk.h>
+
+DatabaseTk::DatabaseTk()
+{
+}
+
+DatabaseTk::~DatabaseTk()
+{
+}
+
+FsckDirEntry DatabaseTk::createDummyFsckDirEntry(FsckDirEntryType entryType)
+{
+   FsckDirEntryList list;
+   createDummyFsckDirEntries(7, 1, &list, entryType);
+   return list.front();
+}
+
+void DatabaseTk::createDummyFsckDirEntries(uint amount, FsckDirEntryList* outList,
+   FsckDirEntryType entryType)
+{
+   createDummyFsckDirEntries(0,amount, outList, entryType);
+}
+
+void DatabaseTk::createDummyFsckDirEntries(uint from, uint amount, FsckDirEntryList* outList,
+   FsckDirEntryType entryType)
+{
+   for ( uint i = from; i < (from+amount); i++ )
+   {
+      std::string index = StringTk::uintToHexStr(i);
+
+      std::string id = index + "-1-1";
+      std::string name = "dentryName" + index;
+      std::string parentID = index + "-2-1";
+      NumNodeID entryOwnerNodeID(i + 1000);
+      NumNodeID inodeOwnerNodeID(i + 2000);
+      NumNodeID saveNodeID(i + 3000);
+      int saveDevice = i;
+      uint64_t saveInode = i;
+
+      FsckDirEntry dentry(id, name, parentID, entryOwnerNodeID, inodeOwnerNodeID, entryType, true,
+         saveNodeID, saveDevice, saveInode, false);
+
+      outList->push_back(dentry);
+   }
+}
+
+FsckFileInode DatabaseTk::createDummyFsckFileInode()
+{
+   FsckFileInodeList list;
+   createDummyFsckFileInodes(7, 1, &list);
+   return list.front();
+}
+
+void DatabaseTk::createDummyFsckFileInodes(uint amount, FsckFileInodeList* outList)
+{
+   createDummyFsckFileInodes(0,amount,outList);
+}
+
+void DatabaseTk::createDummyFsckFileInodes(uint from, uint amount, FsckFileInodeList* outList)
+{
+   for ( uint i = from; i < (from + amount); i++ )
+   {
+      std::string index = StringTk::uintToHexStr(i);
+      UInt16Vector targetIDs;
+      while (targetIDs.size() < i)
+         targetIDs.push_back(i + 1000 * (targetIDs.size() + 1) );
+      Raid0Pattern stripePatternIn(1024, targetIDs);
+
+      std::string id = index + "-1-1";
+      std::string parentDirID = index + "-2-1";
+      NumNodeID parentNodeID(i + 1000);
+
+      unsigned userID = 1000;
+      unsigned groupID = 1000;
+
+      uint64_t usedBlocks = 0;
+      int64_t fileSize = usedBlocks*512;
+      unsigned numHardLinks = 1;
+
+      PathInfo pathInfo(userID, parentDirID, PATHINFO_FEATURE_ORIG);
+
+      FsckStripePatternType stripePatternType = FsckTk::stripePatternToFsckStripePattern(
+         &stripePatternIn);
+      unsigned chunkSize = 524288;
+
+      NumNodeID saveNodeID(i + 2000);
+
+      FsckFileInode fileInode(id, parentDirID, parentNodeID, pathInfo, userID, groupID, fileSize,
+            numHardLinks, usedBlocks, targetIDs, stripePatternType, chunkSize, saveNodeID,
+            1000 + i, 42, true, false, true, false);
+
+      outList->push_back(fileInode);
+   }
+}
+
+FsckDirInode DatabaseTk::createDummyFsckDirInode()
+{
+   FsckDirInodeList list;
+   createDummyFsckDirInodes(7, 1, &list);
+   return list.front();
+}
+
+void DatabaseTk::createDummyFsckDirInodes(uint amount, FsckDirInodeList* outList)
+{
+   createDummyFsckDirInodes(0, amount, outList);
+}
+
+void DatabaseTk::createDummyFsckDirInodes(uint from, uint amount, FsckDirInodeList* outList)
+{
+   for ( uint i = from; i < (from + amount); i++ )
+   {
+      std::string index = StringTk::uintToHexStr(i);
+      UInt16Vector targetIDs;
+      Raid0Pattern stripePatternIn(1024, targetIDs);
+
+      std::string id = index + "-1-1";
+      std::string parentDirID = index + "-2-1";
+      NumNodeID parentNodeID(i + 1000);
+      NumNodeID ownerNodeID(i + 2000);
+
+      int64_t size = 10;
+      unsigned numHardLinks = 12;
+
+      FsckStripePatternType stripePatternType = FsckTk::stripePatternToFsckStripePattern(
+         &stripePatternIn);
+      NumNodeID saveNodeID(i + 3000);
+
+      FsckDirInode dirInode(id, parentDirID, parentNodeID, ownerNodeID, size, numHardLinks,
+         targetIDs, stripePatternType, saveNodeID, false, true, false);
+      outList->push_back(dirInode);
+   }
+}
+
+FsckChunk DatabaseTk::createDummyFsckChunk()
+{
+   FsckChunkList list;
+   createDummyFsckChunks(7, 1, &list);
+   return list.front();
+}
+
+void DatabaseTk::createDummyFsckChunks(uint amount, FsckChunkList* outList)
+{
+   createDummyFsckChunks(amount, 1, outList);
+}
+
+void DatabaseTk::createDummyFsckChunks(uint amount, uint numTargets, FsckChunkList* outList)
+{
+   createDummyFsckChunks(0, amount, numTargets, outList);
+}
+
+void DatabaseTk::createDummyFsckChunks(uint from, uint amount, uint numTargets,
+   FsckChunkList* outList)
+{
+   for ( uint i = from; i < (from + amount); i++ )
+   {
+      std::string index = StringTk::uintToHexStr(i);
+
+      for ( uint j = 0; j < numTargets; j++ )
+      {
+         std::string id = index + "-1-1";
+         uint16_t targetID = j;
+
+         PathInfo pathInfo(0, META_ROOTDIR_ID_STR,  PATHINFO_FEATURE_ORIG);
+         Path chunkDirPath; // ignored!
+         std::string chunkFilePathStr;
+         StorageTk::getChunkDirChunkFilePath(&pathInfo, id, true, chunkDirPath,
+            chunkFilePathStr);
+         Path savedPath(chunkFilePathStr);
+
+         uint64_t usedBlocks = 300;
+         int64_t fileSize = usedBlocks*512;
+
+         FsckChunk chunk(id, targetID, savedPath, fileSize, usedBlocks, 0, 0, 0, 0, 0);
+         outList->push_back(chunk);
+      }
+   }
+}
+
+FsckContDir DatabaseTk::createDummyFsckContDir()
+{
+   FsckContDirList list;
+   createDummyFsckContDirs(7, 1, &list);
+   return list.front();
+}
+
+void DatabaseTk::createDummyFsckContDirs(uint amount, FsckContDirList* outList)
+{
+   createDummyFsckContDirs(0, amount, outList);
+}
+
+void DatabaseTk::createDummyFsckContDirs(uint from, uint amount, FsckContDirList* outList)
+{
+   for ( uint i = from; i < (from + amount); i++ )
+   {
+      std::string index = StringTk::uintToHexStr(i);
+
+      std::string id = index + "-1-1";
+      NumNodeID saveNodeID(i);
+
+      FsckContDir contDir(id, saveNodeID, false);
+      outList->push_back(contDir);
+   }
+}
+
+FsckFsID DatabaseTk::createDummyFsckFsID()
+{
+   FsckFsIDList list;
+   createDummyFsckFsIDs(7, 1, &list);
+   return list.front();
+}
+
+void DatabaseTk::createDummyFsckFsIDs(uint amount, FsckFsIDList* outList)
+{
+   createDummyFsckFsIDs(0, amount, outList);
+}
+
+void DatabaseTk::createDummyFsckFsIDs(uint from, uint amount, FsckFsIDList* outList)
+{
+   for ( uint i = from; i < (from + amount); i++ )
+   {
+      std::string index = StringTk::uintToHexStr(i);
+
+      std::string id = index + "-1-1";
+      std::string parentDirID = index + "-2-1";
+      NumNodeID saveNodeID(i);
+      int saveDevice = i;
+      uint64_t saveInode = i;
+
+      FsckFsID fsID(id, parentDirID, saveNodeID, saveDevice, saveInode, false);
+      outList->push_back(fsID);
+   }
+}
+
+std::string DatabaseTk::calculateExpectedChunkPath(std::string entryID, unsigned origParentUID,
+   std::string origParentEntryID, int pathInfoFlags)
+{
+   std::string resStr;
+
+   bool hasOrigFeature;
+   hasOrigFeature = pathInfoFlags == PATHINFO_FEATURE_ORIG;
+
+   PathInfo pathInfo(origParentUID, origParentEntryID, pathInfoFlags);
+   Path chunkDirPath;
+   std::string chunkFilePath;
+   StorageTk::getChunkDirChunkFilePath(&pathInfo, entryID, hasOrigFeature, chunkDirPath,
+      chunkFilePath);
+
+   if (hasOrigFeature) // we can use the Path chunkDirPath
+      resStr = chunkDirPath.str();
+   else
+   {
+      /* chunk in old format => Path chunkDirPath is not set in getChunkDirChunkFilePath(),
+       * so it is a bit more tricky */
+
+      // we need to strip the filename itself (including the '/')
+      size_t startPos = 0;
+      size_t len = chunkFilePath.find_last_of('/');
+
+      // generate a substring as result
+      resStr = chunkFilePath.substr(startPos, len);
+   }
+
+   return resStr;
+}