summaryrefslogtreecommitdiff
path: root/plugins/common/RESTSupport.vala
diff options
context:
space:
mode:
Diffstat (limited to 'plugins/common/RESTSupport.vala')
-rw-r--r--plugins/common/RESTSupport.vala303
1 files changed, 165 insertions, 138 deletions
diff --git a/plugins/common/RESTSupport.vala b/plugins/common/RESTSupport.vala
index 0d0a3fb..cc810fe 100644
--- a/plugins/common/RESTSupport.vala
+++ b/plugins/common/RESTSupport.vala
@@ -26,6 +26,9 @@ public abstract class Session {
private string? endpoint_url = null;
private Soup.Session soup_session = null;
private bool transactions_stopped = false;
+ private Bytes? body = null;
+ private Error? transport_error= null;
+ private bool insecure = false;
public signal void wire_message_unqueued(Soup.Message message);
public signal void authenticated();
@@ -34,7 +37,18 @@ public abstract class Session {
protected Session(string? endpoint_url = null) {
this.endpoint_url = endpoint_url;
soup_session = new Soup.Session ();
- this.soup_session.ssl_use_system_ca_file = true;
+ if (Environment.get_variable("SHOTWELL_SOUP_LOG") != null) {
+ var logger = new Soup.Logger(Soup.LoggerLogLevel.BODY);
+ logger.set_request_filter((logger, msg) => {
+ var content_type = msg.get_request_headers().get_content_type(null);
+ if (content_type != null && content_type == "application/octet-stream") {
+ return Soup.LoggerLogLevel.HEADERS;
+ }
+
+ return Soup.LoggerLogLevel.BODY;
+ });
+ soup_session.add_feature (logger);
+ }
}
protected void notify_wire_message_unqueued(Soup.Message message) {
@@ -64,19 +78,33 @@ public abstract class Session {
return transactions_stopped;
}
- public void send_wire_message(Soup.Message message) {
- if (are_transactions_stopped())
+ public async void send_wire_message_async(Soup.Message message) {
+ if (are_transactions_stopped()) {
return;
+ }
- soup_session.request_unqueued.connect(notify_wire_message_unqueued);
- soup_session.send_message(message);
-
- soup_session.request_unqueued.disconnect(notify_wire_message_unqueued);
+ try {
+ this.body = yield soup_session.send_and_read_async(message, GLib.Priority.DEFAULT, null);
+ } catch (Error error) {
+ debug ("Failed to send_and_read: %s", error.message);
+ this.transport_error = error;
+ }
}
public void set_insecure () {
- this.soup_session.ssl_use_system_ca_file = false;
- this.soup_session.ssl_strict = false;
+ this.insecure = true;
+ }
+
+ public bool get_is_insecure() {
+ return this.insecure;
+ }
+
+ public Error? get_transport_error() {
+ return this.transport_error;
+ }
+
+ public Bytes? get_body() {
+ return this.body;
}
}
@@ -123,11 +151,19 @@ public class Argument {
this.value = value;
}
- public static string serialize_list(Argument[] args, bool escape = false, string? separator = "&") {
+ public static string serialize_for_sbs(Argument[] args) {
+ return Argument.serialize_list(args, true, false, "&");
+ }
+
+ public static string serialize_for_authorization_header(Argument[] args) {
+ return Argument.serialize_list(args, false, true, ", ");
+ }
+
+ public static string serialize_list(Argument[] args, bool encode, bool escape, string? separator) {
var builder = new StringBuilder("");
foreach (var arg in args) {
- builder.append(arg.to_string(escape));
+ builder.append(arg.to_string(escape, encode));
builder.append(separator);
}
@@ -150,8 +186,10 @@ public class Argument {
return sorted_args.to_array();
}
- public string to_string (bool escape = false) {
- return "%s=%s%s%s".printf (this.key, escape ? "\"" : "", this.value, escape ? "\"" : "");
+ public string to_string (bool escape = false, bool encode = false) {
+ return "%s=%s%s%s".printf (this.key, escape ? "\"" : "",
+ encode ? GLib.Uri.escape_string(this.value) : this.value,
+ escape ? "\"" : "");
}
}
@@ -160,13 +198,12 @@ public class Transaction {
private bool is_executed = false;
private weak Session parent_session = null;
private Soup.Message message = null;
- private int bytes_written = 0;
- private Spit.Publishing.PublishingError? err = null;
+ private uint bytes_written = 0;
+ private ulong request_length;
private string? endpoint_url = null;
private bool use_custom_payload;
- public signal void chunk_transmitted(int bytes_written_so_far, int total_bytes);
- public signal void network_error(Spit.Publishing.PublishingError err);
+ public signal void chunk_transmitted(uint bytes_written_so_far, uint total_bytes);
public signal void completed();
@@ -188,31 +225,16 @@ public class Transaction {
message = new Soup.Message(method.to_string(), endpoint_url);
}
- private void on_wrote_body_data(Soup.Buffer written_data) {
- bytes_written += (int) written_data.length;
- while (Gtk.events_pending()) {
- Gtk.main_iteration();
- }
- chunk_transmitted(bytes_written, (int) message.request_body.length);
- }
-
- private void on_message_unqueued(Soup.Message message) {
- if (this.message != message)
- return;
-
- try {
- check_response(message);
- } catch (Spit.Publishing.PublishingError err) {
- warning("Publishing error: %s", err.message);
- warning("response validation failed. bad response = '%s'.", get_response());
- this.err = err;
- }
+ private void on_wrote_body_data(Soup.Message message, uint chunk_size) {
+ bytes_written += chunk_size;
+ chunk_transmitted(bytes_written, (uint)request_length);
}
/* Texts copied from epiphany */
public string detailed_error_from_tls_flags (out TlsCertificate cert) {
TlsCertificateFlags tls_errors;
- this.message.get_https_status (out cert, out tls_errors);
+ cert = this.message.get_tls_peer_certificate();
+ tls_errors = this.message.get_tls_peer_certificate_errors();
var list = new Gee.ArrayList<string> ();
if (TlsCertificateFlags.BAD_IDENTITY in tls_errors) {
@@ -263,38 +285,38 @@ public class Transaction {
}
protected void check_response(Soup.Message message) throws Spit.Publishing.PublishingError {
- switch (message.status_code) {
- case Soup.KnownStatusCode.OK:
- case Soup.KnownStatusCode.CREATED: // HTTP code 201 (CREATED) signals that a new
- // resource was created in response to a PUT or POST
- break;
-
- case Soup.KnownStatusCode.CANT_RESOLVE:
- case Soup.KnownStatusCode.CANT_RESOLVE_PROXY:
+ var transport_error = parent_session.get_transport_error();
+ if (transport_error != null) {
+ if (transport_error is GLib.ResolverError) {
throw new Spit.Publishing.PublishingError.NO_ANSWER("Unable to resolve %s (error code %u)",
- get_endpoint_url(), message.status_code);
-
- case Soup.KnownStatusCode.CANT_CONNECT:
- case Soup.KnownStatusCode.CANT_CONNECT_PROXY:
+ get_endpoint_url(), message.status_code);
+ }
+ if (transport_error is GLib.IOError) {
throw new Spit.Publishing.PublishingError.NO_ANSWER("Unable to connect to %s (error code %u)",
get_endpoint_url(), message.status_code);
- case Soup.KnownStatusCode.SSL_FAILED:
+ }
+ if (transport_error is GLib.TlsError) {
throw new Spit.Publishing.PublishingError.SSL_FAILED ("Unable to connect to %s: Secure connection failed",
get_endpoint_url ());
+ }
+
+ throw new Spit.Publishing.PublishingError.NO_ANSWER("Failure communicating with %s (error code %u)",
+ get_endpoint_url(), message.status_code);
+ }
+ switch (message.status_code) {
+ case Soup.Status.OK:
+ case Soup.Status.CREATED: // HTTP code 201 (CREATED) signals that a new
+ // resource was created in response to a PUT or POST
+ break;
default:
- // status codes below 100 are used by Soup, 100 and above are defined HTTP codes
- if (message.status_code >= 100) {
- throw new Spit.Publishing.PublishingError.NO_ANSWER("Service %s returned HTTP status code %u %s",
- get_endpoint_url(), message.status_code, message.reason_phrase);
- } else {
- throw new Spit.Publishing.PublishingError.NO_ANSWER("Failure communicating with %s (error code %u)",
- get_endpoint_url(), message.status_code);
- }
+ throw new Spit.Publishing.PublishingError.NO_ANSWER("Service %s returned HTTP status code %u %s",
+ get_endpoint_url(), message.status_code, message.reason_phrase);
}
// All valid communication involves body data in the response
- if (message.response_body.data == null || message.response_body.data.length == 0)
+ var body = parent_session.get_body();
+ if (body == null || body.get_size() == 0)
throw new Spit.Publishing.PublishingError.MALFORMED_RESPONSE("No response data from %s",
get_endpoint_url());
}
@@ -311,22 +333,26 @@ public class Transaction {
this.is_executed = is_executed;
}
- protected void send() throws Spit.Publishing.PublishingError {
- parent_session.wire_message_unqueued.connect(on_message_unqueued);
- message.wrote_body_data.connect(on_wrote_body_data);
- parent_session.send_wire_message(message);
-
- parent_session.wire_message_unqueued.disconnect(on_message_unqueued);
- message.wrote_body_data.disconnect(on_wrote_body_data);
-
- if (err != null)
- network_error(err);
- else
- completed();
-
- if (err != null)
- throw err;
- }
+ private bool on_accecpt_certificate(Soup.Message message, TlsCertificate cert, TlsCertificateFlags errors) {
+ debug ("HTTPS connect error. Will ignore? %s", this.parent_session.get_is_insecure().to_string());
+ return this.parent_session.get_is_insecure();
+ }
+
+ protected async void send_async() throws Spit.Publishing.PublishingError {
+ var id = message.wrote_body_data.connect((message, chunk_size) => {
+ bytes_written = chunk_size;
+
+ chunk_transmitted(bytes_written, (uint)request_length);
+ });
+ message.accept_certificate.connect(on_accecpt_certificate);
+
+ yield parent_session.send_wire_message_async(message);
+ check_response(message);
+
+ message.disconnect(id);
+ message.accept_certificate.disconnect(on_accecpt_certificate);
+ completed();
+ }
public HttpMethod get_method() {
return HttpMethod.from_string(message.method);
@@ -354,7 +380,8 @@ public class Transaction {
}
ulong length = (payload_length > 0) ? payload_length : custom_payload.length;
- message.set_request(payload_content_type, Soup.MemoryUse.COPY, custom_payload.data[0:length]);
+ message.set_request_body_from_bytes(payload_content_type, new Bytes (custom_payload.data[0:length]));
+ this.request_length = length;
use_custom_payload = true;
}
@@ -364,8 +391,9 @@ public class Transaction {
// alone and let the Transaction class manage it for you. You should only need
// to install a new message if your subclass has radically different behavior from
// normal Transactions -- like multipart encoding.
- protected void set_message(Soup.Message message) {
+ protected void set_message(Soup.Message message, ulong request_length) {
this.message = message;
+ this.request_length = request_length;
}
public bool get_is_executed() {
@@ -377,58 +405,67 @@ public class Transaction {
return message.status_code;
}
- public virtual void execute() throws Spit.Publishing.PublishingError {
- // if a custom payload is being used, we don't need to peform the tasks that are necessary
- // to prepare a traditional key-value pair REST request; Instead (since we don't
- // know anything about the custom payload), we just put it on the wire and return
- if (use_custom_payload) {
- is_executed = true;
- send();
-
- return;
- }
-
+ private GLib.Uri? prepare_rest_message() {
// REST POST requests must transmit at least one argument
if (get_method() == HttpMethod.POST)
assert(arguments.length > 0);
// concatenate the REST arguments array into an HTTP formdata string
- string formdata_string = "";
+ var formdata_string = new StringBuilder("");
for (int i = 0; i < arguments.length; i++) {
- formdata_string += arguments[i].to_string ();
+ formdata_string.append(arguments[i].to_string());
if (i < arguments.length - 1)
- formdata_string += "&";
+ formdata_string.append("&");
}
// for GET requests with arguments, append the formdata string to the endpoint url after a
// query divider ('?') -- but make sure to save the old (caller-specified) endpoint URL
// and restore it after the GET so that the underlying Soup message remains consistent
- string old_url = null;
+ GLib.Uri? old_url = null;
string url_with_query = null;
if (get_method() == HttpMethod.GET && arguments.length > 0) {
- old_url = message.get_uri().to_string(false);
- url_with_query = get_endpoint_url() + "?" + formdata_string;
- message.set_uri(new Soup.URI(url_with_query));
+ old_url = message.get_uri();
+ url_with_query = get_endpoint_url() + "?" + formdata_string.str;
+ try {
+ message.set_uri(GLib.Uri.parse(url_with_query, GLib.UriFlags.ENCODED));
+ } catch (Error err) {
+ error ("Invalid uri for service: %s", err.message);
+ }
} else {
- message.set_request("application/x-www-form-urlencoded", Soup.MemoryUse.COPY,
- formdata_string.data);
+ message.set_request_body_from_bytes("application/x-www-form-urlencoded", StringBuilder.free_to_bytes((owned)formdata_string));
}
is_executed = true;
+ return old_url;
+ }
+
+ public virtual async void execute_async() throws Spit.Publishing.PublishingError {
+ // if a custom payload is being used, we don't need to peform the tasks that are necessary
+ // to prepare a traditional key-value pair REST request; Instead (since we don't
+ // know anything about the custom payload), we just put it on the wire and return
+ if (use_custom_payload) {
+ is_executed = true;
+ yield send_async();
+
+ return;
+ }
+
+ var old_url = prepare_rest_message();
+
try {
- debug("sending message to URI = '%s'", message.get_uri().to_string(false));
- send();
+ debug("sending message to URI = '%s'", message.get_uri().to_string());
+ yield send_async();
} finally {
// if old_url is non-null, then restore it
if (old_url != null)
- message.set_uri(new Soup.URI(old_url));
+ message.set_uri(old_url);
}
}
public string get_response() {
assert(get_is_executed());
- return (string) message.response_body.data;
+ return parent_session.get_body() == null ? "" : (string) parent_session.get_body().get_data();
}
public unowned Soup.MessageHeaders get_response_headers() {
@@ -510,7 +547,7 @@ public class UploadTransaction : Transaction {
GLib.HashTable<string, string> result =
new GLib.HashTable<string, string>(GLib.str_hash, GLib.str_equal);
- result.insert("filename", Soup.URI.encode(publishable.get_serialized_file().get_basename(),
+ result.insert("filename", GLib.Uri.escape_string(publishable.get_serialized_file().get_basename(),
null));
return result;
@@ -520,7 +557,7 @@ public class UploadTransaction : Transaction {
binary_disposition_table = new_disp_table;
}
- public override void execute() throws Spit.Publishing.PublishingError {
+ private void prepare_execution() throws Spit.Publishing.PublishingError {
Argument[] request_arguments = get_arguments();
assert(request_arguments.length > 0);
@@ -529,40 +566,40 @@ public class UploadTransaction : Transaction {
foreach (Argument arg in request_arguments)
message_parts.append_form_string(arg.key, arg.value);
- string payload;
- size_t payload_length;
+ MappedFile? mapped_file = null;
try {
- FileUtils.get_contents(publishable.get_serialized_file().get_path(), out payload,
- out payload_length);
- } catch (FileError e) {
+ mapped_file = new MappedFile(publishable.get_serialized_file().get_path(), false);
+ } catch (Error e) {
throw new Spit.Publishing.PublishingError.LOCAL_FILE_ERROR(
_("A temporary file needed for publishing is unavailable"));
}
- int payload_part_num = message_parts.get_length();
-
- Soup.Buffer bindable_data = new Soup.Buffer(Soup.MemoryUse.COPY, payload.data[0:payload_length]);
message_parts.append_form_file("", publishable.get_serialized_file().get_path(), mime_type,
- bindable_data);
+ mapped_file.get_bytes());
unowned Soup.MessageHeaders image_part_header;
- unowned Soup.Buffer image_part_body;
+ unowned Bytes image_part_body;
+ int payload_part_num = message_parts.get_length() - 1;
message_parts.get_part(payload_part_num, out image_part_header, out image_part_body);
+ debug ("Image part header %p", image_part_header);
image_part_header.set_content_disposition("form-data", binary_disposition_table);
- Soup.Message outbound_message =
- Soup.Form.request_new_from_multipart(get_endpoint_url(), message_parts);
- // TODO: there must be a better way to iterate over a map
+ var outbound_message = new Soup.Message.from_multipart(get_endpoint_url(), message_parts);
+
Gee.MapIterator<string, string> i = message_headers.map_iterator();
bool cont = i.next();
while(cont) {
outbound_message.request_headers.append(i.get_key(), i.get_value());
cont = i.next();
}
- set_message(outbound_message);
+ set_message(outbound_message, mapped_file.get_length());
set_is_executed(true);
- send();
+ }
+
+ public override async void execute_async() throws Spit.Publishing.PublishingError {
+ prepare_execution();
+ yield send_async();
}
}
@@ -690,9 +727,8 @@ public abstract class BatchUploader {
this.session = session;
}
- private void send_files() {
+ private async void send_files_async() throws Spit.Publishing.PublishingError {
current_file = 0;
- bool stop = false;
foreach (Spit.Publishing.Publishable publishable in publishables) {
GLib.File? file = publishable.get_serialized_file();
@@ -710,26 +746,15 @@ public abstract class BatchUploader {
txn.chunk_transmitted.connect(on_chunk_transmitted);
- try {
- txn.execute();
- } catch (Spit.Publishing.PublishingError err) {
- upload_error(err);
- stop = true;
- }
+ yield txn.execute_async();
txn.chunk_transmitted.disconnect(on_chunk_transmitted);
-
- if (stop)
- break;
-
+
current_file++;
}
-
- if (!stop)
- upload_complete(current_file);
}
-
- private void on_chunk_transmitted(int bytes_written_so_far, int total_bytes) {
+
+ private void on_chunk_transmitted(uint bytes_written_so_far, uint total_bytes) {
double file_span = 1.0 / publishables.length;
double this_file_fraction_complete = ((double) bytes_written_so_far) / total_bytes;
double fraction_complete = (current_file * file_span) + (this_file_fraction_complete *
@@ -748,12 +773,14 @@ public abstract class BatchUploader {
}
protected abstract Transaction create_transaction(Spit.Publishing.Publishable publishable);
-
- public void upload(Spit.Publishing.ProgressCallback? status_updated = null) {
+
+ public async int upload_async(Spit.Publishing.ProgressCallback? status_updated = null) throws Spit.Publishing.PublishingError {
this.status_updated = status_updated;
if (publishables.length > 0)
- send_files();
+ yield send_files_async();
+
+ return current_file;
}
}