storage/Interface: add virtual method OpenFile()

This should replace most InputStream::Open() calls because it is a
chance to reuse existing resources (e.g. the NFS connection).  No such
optimization is implemented, currently (and the method is not yet used
by anybody).

test/meson.build

@@ -214,6 +214,7 @@ if enable_database
   executable(
     'run_storage',
     'run_storage.cxx',
+    '../src/TagSave.cxx',
     include_directories: inc,
     dependencies: [
       event_dep,

test/run_storage.cxx

@@ -4,10 +4,21 @@
 #include "cmdline/OptionDef.hxx"
 #include "cmdline/OptionParser.hxx"
 #include "event/Thread.hxx"
+#include "ConfigGlue.hxx"
+#include "tag/Tag.hxx"
 #include "storage/Registry.hxx"
 #include "storage/StorageInterface.hxx"
 #include "storage/FileInfo.hxx"
+#include "input/Init.hxx"
+#include "input/InputStream.hxx"
+#include "input/CondHandler.hxx"
+#include "fs/Path.hxx"
+#include "fs/NarrowPath.hxx"
+#include "event/Thread.hxx"
 #include "net/Init.hxx"
+#include "io/BufferedOutputStream.hxx"
+#include "io/FileDescriptor.hxx"
+#include "io/StdioOutputStream.hxx"
 #include "time/ChronoUtil.hxx"
 #include "time/ISO8601.hxx"
 #include "util/PrintException.hxx"
@@ -15,6 +26,12 @@
 #include "util/StringBuffer.hxx"
 #include "Log.hxx"
 #include "LogBackend.hxx"
+#include "TagSave.hxx"
+#include "config.h"
+
+#ifdef ENABLE_ARCHIVE
+#include "archive/ArchiveList.hxx"
+#endif
 
 #include <memory>
 #include <stdexcept>
@@ -32,9 +49,12 @@ Options:
 Available commands:
   ls URI PATH
   stat URI PATH
+  cat URI PATH
 )";
 
 struct CommandLine {
+	FromNarrowPath config_path;
+
 	bool verbose = false;
 
 	const char *command;
@@ -43,10 +63,12 @@ struct CommandLine {
 };
 
 enum class Option {
+	CONFIG,
 	VERBOSE,
 };
 
 static constexpr OptionDef option_defs[] = {
+	{"config", 0, true, "Load a MPD configuration file"},
 	{"verbose", 'v', false, "Verbose logging"},
 };
 
@@ -58,6 +80,10 @@ ParseCommandLine(int argc, char **argv)
 	OptionParser option_parser(option_defs, argc, argv);
 	while (auto o = option_parser.Next()) {
 		switch (static_cast<Option>(o.index)) {
+		case Option::CONFIG:
+			c.config_path = o.value;
+			break;
+
 		case Option::VERBOSE:
 			c.verbose = true;
 			break;
@@ -74,11 +100,20 @@ ParseCommandLine(int argc, char **argv)
 }
 
 class GlobalInit {
+	const ConfigData config;
 	const ScopeNetInit net_init;
 	EventThread io_thread;
 
+#ifdef ENABLE_ARCHIVE
+	const ScopeArchivePluginsInit archive_plugins_init{config};
+#endif
+
+	const ScopeInputPluginsInit input_plugins_init{config, io_thread.GetEventLoop()};
+
 public:
-	GlobalInit() {
+	GlobalInit(Path config_path)
+		:config(AutoLoadConfigFile(config_path))
+	{
 		io_thread.Start();
 	}
 
@@ -159,13 +194,79 @@ Stat(Storage &storage, const char *path)
 	return EXIT_SUCCESS;
 }
 
+static void
+tag_save(FILE *file, const Tag &tag)
+{
+	StdioOutputStream sos(file);
+	WithBufferedOutputStream(sos, [&](auto &bos){
+		tag_save(bos, tag);
+	});
+}
+
+static void
+WaitReady(InputStream &is, std::unique_lock<Mutex> &lock)
+{
+	CondInputStreamHandler handler;
+	is.SetHandler(&handler);
+
+	handler.cond.wait(lock, [&is]{
+		is.Update();
+		return is.IsReady();
+	});
+
+	is.Check();
+}
+
+static void
+Cat(InputStream &is, std::unique_lock<Mutex> &lock, FileDescriptor out)
+{
+	assert(is.IsReady());
+
+	out.SetBinaryMode();
+
+	if (is.HasMimeType())
+		fprintf(stderr, "MIME type: %s\n", is.GetMimeType());
+
+	/* read data and tags from the stream */
+
+	while (!is.IsEOF()) {
+		if (const auto tag = is.ReadTag()) {
+			fprintf(stderr, "Received a tag:\n");
+			tag_save(stderr, *tag);
+		}
+
+		std::byte buffer[16384];
+		const auto nbytes = is.Read(lock, buffer);
+		if (nbytes == 0)
+			break;
+
+		out.FullWrite({buffer, nbytes});
+	}
+
+	is.Check();
+}
+
+static int
+Cat(Storage &storage, const char *path)
+{
+	Mutex mutex;
+	auto is = storage.OpenFile(path, mutex);
+	assert(is);
+
+	std::unique_lock<Mutex> lock(mutex);
+	WaitReady(*is, lock);
+	Cat(*is, lock, FileDescriptor{STDOUT_FILENO});
+
+	return EXIT_SUCCESS;
+}
+
 int
 main(int argc, char **argv)
 try {
 	const auto c = ParseCommandLine(argc, argv);
 
 	SetLogThreshold(c.verbose ? LogLevel::DEBUG : LogLevel::INFO);
-	GlobalInit init;
+	GlobalInit init{c.config_path};
 
 	if (StringIsEqual(c.command, "ls")) {
 		if (c.args.size() != 2) {
@@ -193,6 +294,19 @@ try {
 					   storage_uri);
 
 		return Stat(*storage, path);
+	} else if (StringIsEqual(c.command, "cat")) {
+		if (c.args.size() != 2) {
+			fputs(usage_text, stderr);
+			return EXIT_FAILURE;
+		}
+
+		const char *const storage_uri = c.args[0];
+		const char *const path = c.args[1];
+
+		auto storage = MakeStorage(init.GetEventLoop(),
+					   storage_uri);
+
+		return Cat(*storage, path);
 	} else {
 		fprintf(stderr, "Unknown command\n\n%s", usage_text);
 		return EXIT_FAILURE;