static GArray*
inf_adopted_session_get_xml_user_props(InfSession* session,
InfXmlConnection* conn,
const xmlNodePtr xml)
{
GArray* array;
GParameter* parameter;
InfAdoptedStateVector* vector;
xmlChar* time;
array = INF_SESSION_CLASS(parent_class)->get_xml_user_props(
session,
conn,
xml
);
/* Vector time */
time = inf_xml_util_get_attribute(xml, "time");
if(time != NULL)
{
vector = inf_adopted_state_vector_from_string((const gchar*)time, NULL);
xmlFree(time);
/* TODO: Error reporting for get_xml_user_props */
if(vector != NULL)
{
parameter = inf_session_get_user_property(array, "vector");
g_value_init(¶meter->value, INF_ADOPTED_TYPE_STATE_VECTOR);
g_value_take_boxed(¶meter->value, vector);
}
}
/* log-begin is not in the spec */
#if 0
/* Initial request log, only if ID is also given */
id_param = inf_session_lookup_user_property(
(const GParameter*)array->data,
array->len,
"id"
);
if(id_param != NULL &&
inf_xml_util_get_attribute_uint(xml, "log-begin", &log_begin, NULL))
{
log = inf_adopted_request_log_new(
g_value_get_uint(&id_param->value),
log_begin
);
parameter = inf_session_get_user_property(array, "request-log");
g_value_init(¶meter->value, INF_ADOPTED_TYPE_REQUEST_LOG);
g_value_take_object(¶meter->value, log);
}
#endif
return array;
}
/**
* infc_request_manager_get_request_by_xml:
* @manager: A #InfcRequestManager.
* @name: Name of the expected request. May be %NULL to allow all requests.
* @xml: XML node that is supposed to contain a "seq" attribute.
* @error: Location to store error information.
*
* Looks whether there is a "seq" attribute in @xml. If not, the function
* returns %NULL (without setting @error). Otherwise, it returns the request
* with the given seq and name (if any). If the "seq" attribute is set but
* the actual request is not present (or has another name), the function
* returns %NULL and @error is set.
*
* Return Value: The resulting request, or %NULL if the "seq" attribute was
* not present or an error occured.
**/
InfcRequest*
infc_request_manager_get_request_by_xml(InfcRequestManager* manager,
const gchar* name,
xmlNodePtr xml,
GError** error)
{
InfcRequestManagerPrivate* priv;
InfcRequest* request;
gboolean has_seq;
guint seq;
g_return_val_if_fail(INFC_IS_REQUEST_MANAGER(manager), NULL);
g_return_val_if_fail(xml != NULL, NULL);
priv = INFC_REQUEST_MANAGER_PRIVATE(manager);
request = NULL;
has_seq = inf_xml_util_get_attribute_uint(xml, "seq", &seq, error);
if(has_seq == FALSE) return NULL;
request = infc_request_manager_get_request_by_seq(manager, seq);
if(request == NULL)
{
g_set_error(
error,
inf_request_error_quark(),
INF_REQUEST_ERROR_INVALID_SEQ,
_("The request contains an unknown sequence number")
);
}
else
{
if(name != NULL &&
strcmp(name, infc_request_get_name(request)) != 0)
{
g_set_error(
error,
inf_request_error_quark(),
INF_REQUEST_ERROR_INVALID_SEQ,
_("The request contains a sequence number refering to a request of "
"type '%s', but a request of type '%s' was expected"),
infc_request_get_name(request),
name
);
request = NULL;
}
}
return request;
}
static InfCommunicationScope
inf_adopted_session_process_xml_run(InfSession* session,
InfXmlConnection* connection,
const xmlNodePtr xml,
GError** error)
{
InfAdoptedSessionPrivate* priv;
InfAdoptedSessionClass* session_class;
InfAdoptedRequest* request;
InfAdoptedUser* user;
gboolean has_num;
guint num;
GError* local_error;
InfAdoptedRequest* copy_req;
guint i;
priv = INF_ADOPTED_SESSION_PRIVATE(session);
if(strcmp((const char*)xml->name, "request") == 0)
{
session_class = INF_ADOPTED_SESSION_GET_CLASS(session);
g_assert(session_class->xml_to_request != NULL);
user = inf_adopted_session_user_from_request_xml(
INF_ADOPTED_SESSION(session),
xml,
error
);
if(user == NULL)
return INF_COMMUNICATION_SCOPE_PTP;
if(inf_user_get_status(INF_USER(user)) == INF_USER_UNAVAILABLE ||
inf_user_get_connection(INF_USER(user)) != connection)
{
g_set_error(
error,
inf_user_error_quark(),
INF_USER_ERROR_NOT_JOINED,
"%s",
_("User did not join from this connection")
);
return INF_COMMUNICATION_SCOPE_PTP;
}
local_error = NULL;
has_num = inf_xml_util_get_attribute_uint(xml, "num", &num, &local_error);
if(local_error != NULL)
{
g_propagate_error(error, local_error);
return INF_COMMUNICATION_SCOPE_PTP;
}
request = session_class->xml_to_request(
INF_ADOPTED_SESSION(session),
xml,
inf_adopted_user_get_vector(user),
FALSE,
error
);
if(request == NULL)
return INF_COMMUNICATION_SCOPE_PTP;
inf_adopted_algorithm_receive_request(priv->algorithm, request);
/* Apply the request more than once if num is given. This is mostly used
* for multiple undos and redos, but is in general allowed for any
* request. */
if(has_num)
{
for(i = 1; i < num; ++i)
{
/* TODO: This is a bit of a hack since requests are normally
* immutable. It avoids an additional vector copy here though. */
copy_req = inf_adopted_request_copy(request);
inf_adopted_state_vector_add(
inf_adopted_request_get_vector(copy_req),
inf_user_get_id(INF_USER(user)),
i
);
inf_adopted_algorithm_receive_request(priv->algorithm, copy_req);
g_object_unref(copy_req);
}
}
g_object_unref(request);
/* Requests can always be forwarded since user is given. */
return INF_COMMUNICATION_SCOPE_GROUP;
}
return INF_SESSION_CLASS(parent_class)->process_xml_run(
session,
connection,
xml,
error
);
}
static gboolean
perform_test(guint max_total_log_size,
InfTextChunk* initial,
GSList* users,
GSList* requests,
GError** error)
{
InfTextBuffer* buffer;
InfCommunicationManager* manager;
InfIo* io;
InfTextSession* session;
InfAdoptedAlgorithm* algorithm;
InfUserTable* user_table;
InfTextUser* user;
gchar* user_name;
GSList* item;
xmlNodePtr request;
gboolean result;
GError* local_error;
guint verify_user_id;
InfAdoptedUser* verify_user;
guint verify_log_size;
gint verify_can_undo;
gint verify_can_redo;
InfAdoptedRequestLog* log;
guint log_size;
buffer = INF_TEXT_BUFFER(inf_text_default_buffer_new("UTF-8"));
inf_text_buffer_insert_chunk(buffer, 0, initial, NULL);
manager = inf_communication_manager_new();
io = INF_IO(inf_standalone_io_new());
user_table = inf_user_table_new();
local_error = NULL;
for(item = users; item != NULL; item = g_slist_next(item))
{
user_name = g_strdup_printf("User_%u", GPOINTER_TO_UINT(item->data));
user = INF_TEXT_USER(
g_object_new(
INF_TEXT_TYPE_USER,
"id", GPOINTER_TO_UINT(item->data),
"name", user_name,
"status", INF_USER_ACTIVE,
"flags", 0,
NULL
)
);
g_free(user_name);
inf_user_table_add_user(user_table, INF_USER(user));
g_object_unref(user);
}
session = INF_TEXT_SESSION(
g_object_new(
INF_TEXT_TYPE_SESSION,
"communication-manager", manager,
"buffer", buffer,
"io", io,
"user_table", user_table,
"max-total-log-size", max_total_log_size,
NULL
)
);
algorithm = inf_adopted_session_get_algorithm(INF_ADOPTED_SESSION(session));
g_object_unref(io);
g_object_unref(manager);
g_object_unref(user_table);
g_object_unref(buffer);
for(item = requests; item != NULL; item = item->next)
{
request = (xmlNodePtr)item->data;
if(strcmp((const char*)request->name, "request") == 0)
{
/* Request */
result = inf_communication_object_received(
INF_COMMUNICATION_OBJECT(session),
NULL,
request,
&local_error
);
if(local_error != NULL)
goto fail;
}
else
{
/* TODO: Make an extra function out of this: */
/* Verify */
result = inf_xml_util_get_attribute_uint_required(
request,
"user",
&verify_user_id,
&local_error
);
if(result == FALSE)
goto fail;
verify_user = INF_ADOPTED_USER(
inf_user_table_lookup_user_by_id(user_table, verify_user_id)
);
if(verify_user == NULL)
{
g_set_error(
error,
inf_test_text_cleanup_error_quark(),
INF_TEST_TEXT_CLEANUP_USER_UNAVAILABLE,
"User ID '%u' not available",
verify_user_id
);
goto fail;
}
result = inf_xml_util_get_attribute_uint(
request,
"log-size",
&verify_log_size,
&local_error
);
if(local_error) goto fail;
if(result)
{
log = inf_adopted_user_get_request_log(INF_ADOPTED_USER(verify_user));
log_size = inf_adopted_request_log_get_end(log) -
inf_adopted_request_log_get_begin(log);
if(verify_log_size != log_size)
{
g_set_error(
error,
inf_test_text_cleanup_error_quark(),
INF_TEST_TEXT_CLEANUP_VERIFY_FAILED,
"Log size does not match; got %u, but expected %u",
log_size,
verify_log_size
);
goto fail;
}
}
result = inf_xml_util_get_attribute_int(
request,
"can-undo",
&verify_can_undo,
&local_error
);
if(local_error) goto fail;
if(result)
{
result = inf_adopted_algorithm_can_undo(algorithm, verify_user);
if(result != verify_can_undo)
{
g_set_error(
error,
inf_test_text_cleanup_error_quark(),
INF_TEST_TEXT_CLEANUP_VERIFY_FAILED,
"can-undo does not match; got %d, but expected %d",
(guint)result,
verify_can_undo
);
goto fail;
}
}
result = inf_xml_util_get_attribute_int(
request,
"can-redo",
&verify_can_redo,
&local_error
);
if(local_error) goto fail;
if(result)
{
result = inf_adopted_algorithm_can_redo(algorithm, verify_user);
if(result != verify_can_redo)
{
g_set_error(
error,
inf_test_text_cleanup_error_quark(),
INF_TEST_TEXT_CLEANUP_VERIFY_FAILED,
"can-redo does not match; got %d, but expected %d",
(guint)result,
verify_can_redo
);
goto fail;
}
}
}
}
g_object_unref(session);
return TRUE;
fail:
g_object_unref(session);
if(local_error) g_propagate_error(error, local_error);
return FALSE;
}
