verify that we can read input files that are only hashed (#333)

* output build and part details by default
* output executable and version at start of builds command
* verify that we can read files we do not chunk

2 files changed, 122 insertions, 7 deletions

diff --git a/src/zen/cmds/builds_cmd.cpp b/src/zen/cmds/builds_cmd.cpp
index eebb6d82b..689b29db5 100644
--- a/src/zen/cmds/builds_cmd.cpp
+++ b/src/zen/cmds/builds_cmd.cpp
@@ -6,7 +6,9 @@
 #include <zencore/compactbinarybuilder.h>
 #include <zencore/compactbinaryfile.h>
 #include <zencore/compactbinaryfmt.h>
+#include <zencore/compactbinaryvalue.h>
 #include <zencore/compress.h>
+#include <zencore/config.h>
 #include <zencore/except.h>
 #include <zencore/filesystem.h>
 #include <zencore/fmtutils.h>
@@ -7061,6 +7063,107 @@ namespace {
 		}
 	}
 
+	std::string GetCbObjectAsNiceString(CbObjectView Object, std::string_view Prefix, std::string_view Suffix)
+	{
+		ExtendableStringBuilder<512>					 SB;
+		std::vector<std::pair<std::string, std::string>> NameStringValuePairs;
+		for (CbFieldView Field : Object)
+		{
+			std::string_view Name = Field.GetName();
+			switch (CbValue Accessor = Field.GetValue(); Accessor.GetType())
+			{
+				case CbFieldType::String:
+					NameStringValuePairs.push_back({std::string(Name), std::string(Accessor.AsString())});
+					break;
+				case CbFieldType::IntegerPositive:
+					NameStringValuePairs.push_back({std::string(Name), fmt::format("{}", Accessor.AsIntegerPositive())});
+					break;
+				case CbFieldType::IntegerNegative:
+					NameStringValuePairs.push_back({std::string(Name), fmt::format("{}", Accessor.AsIntegerNegative())});
+					break;
+				case CbFieldType::Float32:
+					{
+						const float Value = Accessor.AsFloat32();
+						if (std::isfinite(Value))
+						{
+							NameStringValuePairs.push_back({std::string(Name), fmt::format("{:.9g}", Value)});
+						}
+						else
+						{
+							NameStringValuePairs.push_back({std::string(Name), "null"});
+						}
+					}
+					break;
+				case CbFieldType::Float64:
+					{
+						const double Value = Accessor.AsFloat64();
+						if (std::isfinite(Value))
+						{
+							NameStringValuePairs.push_back({std::string(Name), fmt::format("{:.17g}", Value)});
+						}
+						else
+						{
+							NameStringValuePairs.push_back({std::string(Name), "null"});
+						}
+					}
+					break;
+				case CbFieldType::BoolFalse:
+					NameStringValuePairs.push_back({std::string(Name), "false"});
+					break;
+				case CbFieldType::BoolTrue:
+					NameStringValuePairs.push_back({std::string(Name), "true"});
+					break;
+				case CbFieldType::Hash:
+					{
+						NameStringValuePairs.push_back({std::string(Name), Accessor.AsHash().ToHexString()});
+					}
+					break;
+				case CbFieldType::Uuid:
+					{
+						StringBuilder<Oid::StringLength + 1> Builder;
+						Accessor.AsUuid().ToString(Builder);
+						NameStringValuePairs.push_back({std::string(Name), Builder.ToString()});
+					}
+					break;
+				case CbFieldType::DateTime:
+					{
+						ExtendableStringBuilder<64> Builder;
+						Builder << DateTime(Accessor.AsDateTimeTicks()).ToIso8601();
+						NameStringValuePairs.push_back({std::string(Name), Builder.ToString()});
+					}
+					break;
+				case CbFieldType::TimeSpan:
+					{
+						ExtendableStringBuilder<64> Builder;
+						const TimeSpan				Span(Accessor.AsTimeSpanTicks());
+						if (Span.GetDays() == 0)
+						{
+							Builder << Span.ToString("%h:%m:%s.%n");
+						}
+						else
+						{
+							Builder << Span.ToString("%d.%h:%m:%s.%n");
+						}
+						NameStringValuePairs.push_back({std::string(Name), Builder.ToString()});
+						break;
+					}
+				case CbFieldType::ObjectId:
+					NameStringValuePairs.push_back({std::string(Name), Accessor.AsObjectId().ToString()});
+					break;
+			}
+		}
+		std::string::size_type LongestKey = 0;
+		for (const std::pair<std::string, std::string>& KeyValue : NameStringValuePairs)
+		{
+			LongestKey = Max(KeyValue.first.length(), LongestKey);
+		}
+		for (const std::pair<std::string, std::string>& KeyValue : NameStringValuePairs)
+		{
+			SB.Append(fmt::format("{}{:<{}}: {}{}", Prefix, KeyValue.first, LongestKey, KeyValue.second, Suffix));
+		}
+		return SB.ToString();
+	}
+
 	std::vector<std::pair<Oid, std::string>> ResolveBuildPartNames(BuildStorage&				Storage,
 																   const Oid&					BuildId,
 																   const std::vector<Oid>&		BuildPartIds,
@@ -7071,14 +7174,12 @@ namespace {
 		{
 			Stopwatch GetBuildTimer;
 			CbObject  BuildObject = Storage.GetBuild(BuildId);
-			ZEN_CONSOLE("GetBuild took {}. Name: '{}' ({}, {}), Payload size: {}",
+			ZEN_CONSOLE("GetBuild took {}. Name: '{}', Payload size: {}",
 						NiceTimeSpanMs(GetBuildTimer.GetElapsedTimeMs()),
 						BuildObject["name"sv].AsString(),
-						BuildObject["type"sv].AsString(),
-						BuildObject["Configuration"sv].AsString(),
 						NiceBytes(BuildObject.GetSize()));
 
-			ZEN_CONSOLE_VERBOSE("Build object: {}", BuildObject);
+			ZEN_CONSOLE("{}", GetCbObjectAsNiceString(BuildObject, "    "sv, "\n"sv));
 
 			CbObjectView PartsObject = BuildObject["parts"sv].AsObjectView();
 			if (!PartsObject)
@@ -7170,6 +7271,7 @@ namespace {
 					BuildPartName,
 					NiceTimeSpanMs(GetBuildPartTimer.GetElapsedTimeMs()),
 					NiceBytes(BuildPartManifest.GetSize()));
+		ZEN_CONSOLE("{}", GetCbObjectAsNiceString(BuildPartManifest, "    "sv, "\n"sv));
 
 		{
 			CbObjectView	 Chunker	 = BuildPartManifest["chunker"sv].AsObjectView();
@@ -8750,6 +8852,10 @@ BuildsCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 	{
 		if (SubOption == &m_ListOptions)
 		{
+			if (!m_ListResultPath.empty())
+			{
+				ZEN_CONSOLE("Running {}: {}", GetRunningExecutablePath(), ZEN_CFG_VERSION_BUILD_STRING_FULL);
+			}
 			CbObject QueryObject;
 			if (m_ListQueryPath.empty())
 			{
@@ -8824,6 +8930,8 @@ BuildsCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 
 		if (SubOption == &m_UploadOptions)
 		{
+			ZEN_CONSOLE("Running {}: {}", GetRunningExecutablePath(), ZEN_CFG_VERSION_BUILD_STRING_FULL);
+
 			if (m_Path.empty())
 			{
 				throw zen::OptionParseException(fmt::format("local-path is required\n{}", m_UploadOptions.help()));
@@ -8979,6 +9087,8 @@ BuildsCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 
 		if (SubOption == &m_DownloadOptions)
 		{
+			ZEN_CONSOLE("Running {}: {}", GetRunningExecutablePath(), ZEN_CFG_VERSION_BUILD_STRING_FULL);
+
 			if (m_Path.empty())
 			{
 				throw zen::OptionParseException(fmt::format("local-path is required\n{}", m_DownloadOptions.help()));
@@ -9472,6 +9582,7 @@ BuildsCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 
 		if (SubOption == &m_FetchBlobOptions)
 		{
+			ZEN_CONSOLE("Running {}: {}", GetRunningExecutablePath(), ZEN_CFG_VERSION_BUILD_STRING_FULL);
 			if (m_BlobHash.empty())
 			{
 				throw zen::OptionParseException(fmt::format("Blob hash string is missing\n{}", m_UploadOptions.help()));
@@ -9519,7 +9630,7 @@ BuildsCommand::Run(const ZenCliOptions& GlobalOptions, int argc, char** argv)
 
 		if (SubOption == &m_ValidateBuildPartOptions)
 		{
-			//			HttpClient Http(m_BuildsUrl, ClientSettings);
+			ZEN_CONSOLE("Running {}: {}", GetRunningExecutablePath(), ZEN_CFG_VERSION_BUILD_STRING_FULL);
 
 			if (m_BuildsUrl.empty() && m_StoragePath.empty())
 			{
diff --git a/src/zenutil/chunkedcontent.cpp b/src/zenutil/chunkedcontent.cpp
index 1e8447a57..32ae2d94a 100644
--- a/src/zenutil/chunkedcontent.cpp
+++ b/src/zenutil/chunkedcontent.cpp
@@ -140,8 +140,12 @@ namespace {
 			{
 				ZEN_TRACE_CPU("HashOnly");
 
-				IoBuffer	 Buffer = IoBufferBuilder::MakeFromFile((FolderPath / Path).make_preferred());
-				const IoHash Hash	= IoHash::HashBuffer(Buffer, &Stats.BytesHashed);
+				IoBuffer Buffer = IoBufferBuilder::MakeFromFile((FolderPath / Path).make_preferred());
+				if (Buffer.GetSize() != RawSize)
+				{
+					throw std::runtime_error(fmt::format("Failed opening file '{}' for hashing", FolderPath / Path));
+				}
+				const IoHash Hash = IoHash::HashBuffer(Buffer, &Stats.BytesHashed);
 
 				Lock.WithExclusiveLock([&]() {
 					if (!RawHashToSequenceRawHashIndex.contains(Hash))