#include "dcpomatic_assert.h"
#include "disk_writer_messages.h"
#include "nanomsg.h"
+#include <dcp/raw_convert.h>
+using std::string;
using boost::optional;
} else if (*s == DISK_WRITER_ERROR) {
auto const m = nanomsg.receive(500);
auto const n = nanomsg.receive(500);
- return DiskWriterBackEndResponse::error(m.get_value_or(""), dcp::locale_convert<int>(n.get_value_or("0")));
+ return DiskWriterBackEndResponse::error(m.get_value_or(""), dcp::raw_convert<int>(n.get_value_or("0")));
} else if (*s == DISK_WRITER_PONG) {
return DiskWriterBackEndResponse::pong();
} else if (*s == DISK_WRITER_FORMAT_PROGRESS) {
auto progress = nanomsg.receive(500);
- return DiskWriterBackEndResponse::format_progress(dcp::locale_convert<float>(progress.get_value_or("0")));
+ return DiskWriterBackEndResponse::format_progress(dcp::raw_convert<float>(progress.get_value_or("0")));
} else if (*s == DISK_WRITER_COPY_PROGRESS) {
auto progress = nanomsg.receive(500);
- return DiskWriterBackEndResponse::copy_progress(dcp::locale_convert<float>(progress.get_value_or("0")));
+ return DiskWriterBackEndResponse::copy_progress(dcp::raw_convert<float>(progress.get_value_or("0")));
} else if (*s == DISK_WRITER_VERIFY_PROGRESS) {
auto progress = nanomsg.receive(500);
- return DiskWriterBackEndResponse::verify_progress(dcp::locale_convert<float>(progress.get_value_or("0")));
+ return DiskWriterBackEndResponse::verify_progress(dcp::raw_convert<float>(progress.get_value_or("0")));
} else {
DCPOMATIC_ASSERT(false);
}
return {};
}
+
+/** @return true if the message was sent, false if there was a timeout */
+bool
+DiskWriterBackEndResponse::write_to_nanomsg(Nanomsg& nanomsg, int timeout) const
+{
+ string message;
+
+ switch (_type)
+ {
+ case Type::OK:
+ message = String::compose("%1\n", DISK_WRITER_OK);
+ break;
+ case Type::ERROR:
+ message = String::compose("%1\n%2\n%3\n", DISK_WRITER_ERROR, _error_message, _error_number);
+ break;
+ case Type::PONG:
+ message = String::compose("%1\n", DISK_WRITER_PONG);
+ break;
+ case Type::FORMAT_PROGRESS:
+ message = String::compose("%1\n", DISK_WRITER_FORMAT_PROGRESS);
+ message += dcp::raw_convert<string>(_progress) + "\n";
+ break;
+ case Type::COPY_PROGRESS:
+ message = String::compose("%1\n", DISK_WRITER_COPY_PROGRESS);
+ message += dcp::raw_convert<string>(_progress) + "\n";
+ break;
+ case Type::VERIFY_PROGRESS:
+ message = String::compose("%1\n", DISK_WRITER_VERIFY_PROGRESS);
+ message += dcp::raw_convert<string>(_progress) + "\n";
+ break;
+ }
+
+
+ return nanomsg.send(message, timeout);
+}
+
+
static boost::optional<DiskWriterBackEndResponse> read_from_nanomsg(Nanomsg& nanomsg, int timeout);
+ bool write_to_nanomsg(Nanomsg& nanomsg, int timeout) const;
+
Type type() const {
return _type;
}
++progress_count;
if ((progress_count % progress_frequency) == 0 && nanomsg) {
- nanomsg->send(String::compose(DISK_WRITER_COPY_PROGRESS "\n%1\n", (1 - float(total_remaining) / total)), SHORT_TIMEOUT);
+ DiskWriterBackEndResponse::copy_progress(1 - float(total_remaining) / total).write_to_nanomsg(*nanomsg, SHORT_TIMEOUT);
}
}
remaining -= this_time;
total_remaining -= this_time;
if (nanomsg) {
- nanomsg->send(String::compose(DISK_WRITER_VERIFY_PROGRESS "\n%1\n", (1 - float(total_remaining) / total)), SHORT_TIMEOUT);
+ DiskWriterBackEndResponse::verify_progress(1 - float(total_remaining) / total).write_to_nanomsg(*nanomsg, SHORT_TIMEOUT);
}
}
format_progress (void* context, float progress)
{
if (context) {
- reinterpret_cast<Nanomsg*>(context)->send(String::compose(DISK_WRITER_FORMAT_PROGRESS "\n%1\n", progress), SHORT_TIMEOUT);
+ DiskWriterBackEndResponse::format_progress(progress).write_to_nanomsg(*reinterpret_cast<Nanomsg*>(context), SHORT_TIMEOUT);
}
}
}
ext4_device_unregister("ext4_fs");
- if (nanomsg && !nanomsg->send(DISK_WRITER_OK "\n", LONG_TIMEOUT)) {
+ if (nanomsg && !DiskWriterBackEndResponse::ok().write_to_nanomsg(*nanomsg, LONG_TIMEOUT)) {
throw CommunicationFailedError ();
}
} catch (CopyError& e) {
LOG_DISK("CopyError (from write): %1 %2", e.message(), e.number().get_value_or(0));
if (nanomsg) {
- nanomsg->send(String::compose(DISK_WRITER_ERROR "\n%1\n%2\n", e.message(), e.number().get_value_or(0)), LONG_TIMEOUT);
+ DiskWriterBackEndResponse::error(e.message(), e.number().get_value_or(0)).write_to_nanomsg(*nanomsg, LONG_TIMEOUT);
}
} catch (VerifyError& e) {
LOG_DISK("VerifyError (from write): %1 %2", e.message(), e.number());
if (nanomsg) {
- nanomsg->send(String::compose(DISK_WRITER_ERROR "\n%1\n%2\n", e.message(), e.number()), LONG_TIMEOUT);
+ DiskWriterBackEndResponse::error(e.message(), e.number()).write_to_nanomsg(*nanomsg, LONG_TIMEOUT);
}
} catch (exception& e) {
LOG_DISK("Exception (from write): %1", e.what());
if (nanomsg) {
- nanomsg->send(String::compose(DISK_WRITER_ERROR "\n%1\n0\n", e.what()), LONG_TIMEOUT);
+ DiskWriterBackEndResponse::error(e.what(), 0).write_to_nanomsg(*nanomsg, LONG_TIMEOUT);
}
}
if (*s == DISK_WRITER_QUIT) {
exit (EXIT_SUCCESS);
} else if (*s == DISK_WRITER_PING) {
- nanomsg->send(DISK_WRITER_PONG "\n", LONG_TIMEOUT);
+ DiskWriterBackEndResponse::pong().write_to_nanomsg(*nanomsg, LONG_TIMEOUT);
} else if (*s == DISK_WRITER_UNMOUNT) {
auto xml_head = nanomsg->receive (LONG_TIMEOUT);
auto xml_body = nanomsg->receive (LONG_TIMEOUT);
bool const success = Drive(xml).unmount();
bool sent_reply = false;
if (success) {
- sent_reply = nanomsg->send(DISK_WRITER_OK "\n", LONG_TIMEOUT);
+ sent_reply = DiskWriterBackEndResponse::ok().write_to_nanomsg(*nanomsg, LONG_TIMEOUT);
} else {
- sent_reply = nanomsg->send(DISK_WRITER_ERROR "\nCould not unmount drive\n1\n", LONG_TIMEOUT);
+ sent_reply = DiskWriterBackEndResponse::error("Could not unmount drive", 1).write_to_nanomsg(*nanomsg, LONG_TIMEOUT);
}
if (!sent_reply) {
LOG_DISK_NC("CommunicationFailedError in unmount_finished");
}
},
[]() {
- if (!nanomsg->send(DISK_WRITER_ERROR "\nCould not get permission to unmount drive\n1\n", LONG_TIMEOUT)) {
+ if (!DiskWriterBackEndResponse::error("Could not get permission to unmount drive", 1).write_to_nanomsg(*nanomsg, LONG_TIMEOUT)) {
LOG_DISK_NC("CommunicationFailedError in unmount_finished");
throw CommunicationFailedError ();
}
#ifdef DCPOMATIC_OSX
if (!starts_with(device, "/dev/disk")) {
LOG_DISK ("Will not write to %1", device);
- nanomsg->send(DISK_WRITER_ERROR "\nRefusing to write to this drive\n1\n", LONG_TIMEOUT);
+ DiskWriterBackEndResponse::error("Refusing to write to this drive", 1).write_to_nanomsg(*nanomsg, LONG_TIMEOUT);
return true;
}
#endif
#ifdef DCPOMATIC_LINUX
if (!starts_with(device, "/dev/sd") && !starts_with(device, "/dev/hd")) {
LOG_DISK ("Will not write to %1", device);
- nanomsg->send(DISK_WRITER_ERROR "\nRefusing to write to this drive\n1\n", LONG_TIMEOUT);
+ DiskWriterBackEndResponse::error("Refusing to write to this drive", 1).write_to_nanomsg(*nanomsg, LONG_TIMEOUT);
return true;
}
#endif
#ifdef DCPOMATIC_WINDOWS
if (!starts_with(device, "\\\\.\\PHYSICALDRIVE")) {
LOG_DISK ("Will not write to %1", device);
- nanomsg->send(DISK_WRITER_ERROR "\nRefusing to write to this drive\n1\n", LONG_TIMEOUT);
+ DiskWriterBackEndResponse::error("Refusing to write to this drive", 1).write_to_nanomsg(*nanomsg, LONG_TIMEOUT);
return true;
}
#endif
if (!on_drive_list) {
LOG_DISK ("Will not write to %1 as it's not recognised as a drive", device);
- nanomsg->send(DISK_WRITER_ERROR "\nRefusing to write to this drive\n1\n", LONG_TIMEOUT);
+ DiskWriterBackEndResponse::error("Refusing to write to this drive", 1).write_to_nanomsg(*nanomsg, LONG_TIMEOUT);
return true;
}
if (mounted) {
LOG_DISK ("Will not write to %1 as it's mounted", device);
- nanomsg->send(DISK_WRITER_ERROR "\nRefusing to write to this drive\n1\n", LONG_TIMEOUT);
+ DiskWriterBackEndResponse::error("Refusing to write to this drive", 1).write_to_nanomsg(*nanomsg, LONG_TIMEOUT);
return true;
}
},
[]() {
if (nanomsg) {
- nanomsg->send(DISK_WRITER_ERROR "\nCould not obtain authorization to write to the drive\n1\n", LONG_TIMEOUT);
+ DiskWriterBackEndResponse::error("Could not obtain authorization to write to the drive", 1).write_to_nanomsg(*nanomsg, LONG_TIMEOUT);
}
});
}