More error handling improvements* (4acda31e) · Commits · olcf / container-builder

Builder/main.cpp

+19 −7

Original line number	Diff line number	Diff line
		@@ -29,8 +29,14 @@ int main(int argc, char *argv[]) {
		// Once we're connected start the build process
		asio::spawn(io_service,
		[&](asio::yield_context yield) {
		boost::system::error_code error;

		// Receive the definition file from the client
		messenger.async_receive_file("container.def", yield);
		messenger.async_receive_file("container.def", yield[error]);
		if(error) {
		logger::write("Error receiving definition file: " + error.message());
		return;
		}

		logger::write(socket, "Received container.def");

		@@ -49,6 +55,7 @@ int main(int argc, char *argv[]) {
		group, build_ec);
		if (build_ec) {
		logger::write(socket, "subprocess error: " + build_ec.message());
		return;
		}

		logger::write(socket, "launched build process: " + build_command);
		@@ -61,13 +68,18 @@ int main(int argc, char *argv[]) {
		asio::streambuf buffer;
		boost::regex line_matcher{"\\r\|\\n"};
		std::size_t read_size = 0;
		boost::system::error_code err_code;
		do {
		// Read from the pipe into a buffer
		read_size = asio::async_read_until(std_pipe, buffer, line_matcher, yield[err_code]);
		read_size = asio::async_read_until(std_pipe, buffer, line_matcher, yield[error]);
		if(error) {
		logger::write(socket, "reading process pipe failed: " + error.message());
		}
		// Write the buffer to our socket
		messenger.async_send(buffer, yield);
		} while (read_size > 0 && err_code == boost::system::errc::success);
		messenger.async_send(buffer, yield[error]);
		if(error) {
		logger::write(socket, "sending process pipe failed: " + error.message());
		}
		} while (read_size > 0 && !error);

		// Get the return value from the build subprocess
		logger::write(socket, "Waiting on build process to exit");
		@@ -86,8 +98,8 @@ int main(int argc, char *argv[]) {
		// Begin processing our connections and queue
		io_service.run();
		}
		catch (std::exception &e) {
		logger::write(std::string() + "Build server exception: " + e.what());
		catch (...) {
		logger::write("Unknown builder exception encountered");
		}

		logger::write("Builder shutting down");

BuilderQueue/src/BuilderQueue.cpp

+12 −12

Original line number	Diff line number	Diff line
		@@ -9,10 +9,10 @@ Reservation &BuilderQueue::enter() {

		void BuilderQueue::tick(asio::yield_context yield) {
		// Update list of "Active" OpenStack builders
		boost::system::error_code ec;
		auto all_builders = OpenStackBuilder::get_builders(io_service, yield[ec]);
		if (ec) {
		logger::write("Error calling get_builders" + ec.message());
		boost::system::error_code error;
		auto all_builders = OpenStackBuilder::get_builders(io_service, yield[error]);
		if (error) {
		logger::write("Error calling get_builders" + error.message());
		return;
		}

		@@ -34,10 +34,10 @@ void BuilderQueue::tick(asio::yield_context yield) {
		reservation.set_enter_cleanup();
		asio::spawn(io_service,
		[this, &reservation](asio::yield_context destroy_yield) {
		boost::system::error_code ec;
		OpenStackBuilder::destroy(reservation.builder.get(), io_service, destroy_yield[ec]);
		if (ec) {
		logger::write("Error destryoing builder " + ec.message());
		boost::system::error_code error;
		OpenStackBuilder::destroy(reservation.builder.get(), io_service, destroy_yield[error]);
		if (error) {
		logger::write("Error destryoing builder " + error.message());
		} else {
		reservation.set_finalize();
		}
		@@ -70,10 +70,10 @@ void BuilderQueue::tick(asio::yield_context yield) {
		pending_requests++;
		asio::spawn(io_service,
		[this](asio::yield_context request_yield) {
		boost::system::error_code ec;
		OpenStackBuilder::request_create(io_service, request_yield[ec]);
		if (ec) {
		logger::write("Error requesting builder create " + ec.message());
		boost::system::error_code error;
		OpenStackBuilder::request_create(io_service, request_yield[error]);
		if (error) {
		logger::write("Error requesting builder create " + error.message());
		} else {
		pending_requests--;
		}

BuilderQueue/src/Connection.cpp

+13 −13

Original line number	Diff line number	Diff line
		@@ -9,10 +9,10 @@ void Connection::begin() {
		asio::spawn(socket.get_io_service(),
		[this, self](asio::yield_context yield) {
		Messenger messenger(socket);
		boost::system::error_code ec;
		auto request = messenger.async_receive(yield[ec], MessageType::string);
		if (ec) {
		logger::write(socket, "Request failure" + ec.message());
		boost::system::error_code error;
		auto request = messenger.async_receive(yield[error], MessageType::string);
		if (error) {
		logger::write(socket, "Request failure" + error.message());
		} else if (request == "checkout_builder_request") {
		checkout_builder(yield[ec]);
		} else {
		@@ -27,31 +27,31 @@ void Connection::begin() {
		// Handle a client builder request
		void Connection::checkout_builder(asio::yield_context yield) {
		logger::write(socket, "Checkout resource request");
		boost::system::error_code ec;
		boost::system::error_code error;

		Messenger messenger(socket);

		// Request a builder
		logger::write(socket, "Requesting builder from the queue");
		ReservationRequest reservation(queue);
		Builder builder = reservation.async_wait(yield[ec]);
		if (ec) {
		logger::write("reservation builder request failed: " + ec.message());
		Builder builder = reservation.async_wait(yield[error]);
		if (error) {
		logger::write("reservation builder request failed: " + error.message());
		return;
		}

		// Send the fulfilled builder
		messenger.async_send(builder, yield[ec]);
		if (ec) {
		messenger.async_send(builder, yield[error]);
		if (error) {
		logger::write(socket, "Error sending builder: " + builder.id + "(" + builder.host + ")");
		return;
		}

		// Wait on connection to finish
		logger::write(socket, "Sent builder: " + builder.id + "(" + builder.host + ")");
		std::string complete = messenger.async_receive(yield[ec], MessageType::string);
		if (ec \|\| complete != "checkout_builder_complete") {
		logger::write(socket, "Failed to receive completion message from client" + ec.message());
		std::string complete = messenger.async_receive(yield[error], MessageType::string);
		if (error \|\| complete != "checkout_builder_complete") {
		logger::write(socket, "Failed to receive completion message from client" + error.message());
		return;
		}

BuilderQueue/src/OpenStackBuilder.cpp

+20 −20

Original line number	Diff line number	Diff line
		@@ -15,18 +15,18 @@ namespace OpenStackBuilder {
		asio::streambuf buffer;

		// Asynchronously launch the list command
		std::error_code list_ec;
		std::error_code list_error;
		logger::write("Running command: " + list_command);
		bp::child list_child(list_command, bp::std_in.close(), (bp::std_out & bp::std_err) > std_pipe, group, list_ec);
		if (list_ec) {
		logger::write("subprocess error: " + list_ec.message());
		bp::child list_child(list_command, bp::std_in.close(), (bp::std_out & bp::std_err) > std_pipe, group, list_error);
		if (list_error) {
		logger::write("subprocess error: " + list_error.message());
		}

		// Read the list command output until we reach EOF, which is returned as an error
		boost::system::error_code read_ec;
		boost::asio::async_read(std_pipe, buffer, yield[read_ec]);
		if (read_ec != asio::error::eof) {
		logger::write("OpenStack destroy error: " + read_ec.message());
		boost::system::error_code read_error;
		boost::asio::async_read(std_pipe, buffer, yield[read_error]);
		if (read_error != asio::error::eof) {
		logger::write("OpenStack destroy error: " + read_error.message());
		}

		// Grab exit code from destroy command
		@@ -81,19 +81,19 @@ namespace OpenStackBuilder {
		asio::streambuf buffer;

		// Asynchronously launch the create command
		std::error_code create_ec;
		std::error_code create_error;
		logger::write("Running command: " + create_command);
		bp::child build_child(create_command, bp::std_in.close(), (bp::std_out & bp::std_err) > std_pipe, group,
		create_ec);
		if (create_ec) {
		logger::write("subprocess error: " + create_ec.message());
		create_error);
		if (create_error) {
		logger::write("subprocess error: " + create_error.message());
		}

		// Read the create_command output until we reach EOF, which is returned as an error
		boost::system::error_code read_ec;
		boost::asio::async_read(std_pipe, buffer, yield[read_ec]);
		if (read_ec != asio::error::eof) {
		logger::write("OpenStack create error: " + read_ec.message());
		boost::system::error_code read_error;
		boost::asio::async_read(std_pipe, buffer, yield[read_error]);
		if (read_error != asio::error::eof) {
		logger::write("OpenStack create error: " + read_error.message());
		}

		// Grab exit code from builder
		@@ -112,12 +112,12 @@ namespace OpenStackBuilder {
		asio::streambuf buffer;

		// Asynchronously launch the destroy command
		std::error_code destroy_ec;
		std::error_code destroy_error;
		logger::write("Running command: " + destroy_command);
		bp::child destroy_child(destroy_command, bp::std_in.close(), (bp::std_out & bp::std_err) > std_pipe, group,
		destroy_ec);
		if (destroy_ec) {
		logger::write("subprocess error: " + destroy_ec.message());
		destroy_error);
		if (destroy_error) {
		logger::write("subprocess error: " + destroy_error.message());
		}

		// Read the destroy_command output until we reach EOF, which is returned as an error

BuilderQueue/src/Reservation.cpp

+4 −4

Original line number	Diff line number	Diff line
		@@ -8,10 +8,10 @@ void Reservation::async_wait(asio::yield_context yield) {
		if (status == ReservationStatus::pending) {
		ready_timer.expires_at(boost::posix_time::pos_infin);
		// On timer cancel we will get an operation aborted error from async_wait
		boost::system::error_code ec;
		ready_timer.async_wait(yield[ec]);
		if (ec != asio::error::operation_aborted) {
		logger::write("Error in reservation async_wait" + ec.message());
		boost::system::error_code error;
		ready_timer.async_wait(yield[error]);
		if (error != asio::error::operation_aborted) {
		logger::write("Error in reservation async_wait" + error.message());
		return;
		}
		}