FS-10167: Preliminary support for blade.execute, tested with a basic test.echo…

FS-10167: Preliminary support for blade.execute, tested with a basic test.echo across 3 nodes with a common master. Multitier routing is not yet fully supported

libs/libblade/libblade.vcxproj

@@ -190,7 +190,7 @@
     <ClCompile Include="src\blade.c" />
     <ClCompile Include="src\blade_connection.c" />
     <ClCompile Include="src\blade_identity.c" />
-    <ClCompile Include="src\blade_jsonrpc.c" />
+    <ClCompile Include="src\blade_rpc.c" />
     <ClCompile Include="src\blade_protocol.c" />
     <ClCompile Include="src\blade_transport_wss.c" />
     <ClCompile Include="src\blade_session.c" />
@@ -202,7 +202,7 @@
     <ClInclude Include="src\include\blade.h" />
     <ClInclude Include="src\include\blade_connection.h" />
     <ClInclude Include="src\include\blade_identity.h" />
-    <ClInclude Include="src\include\blade_jsonrpc.h" />
+    <ClInclude Include="src\include\blade_rpc.h" />
     <ClInclude Include="src\include\blade_protocol.h" />
     <ClInclude Include="src\include\blade_transport_wss.h" />
     <ClInclude Include="src\include\blade_session.h" />

libs/libblade/libblade.vcxproj.filters

@@ -36,15 +36,15 @@
     <ClCompile Include="src\blade_transport.c">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="src\blade_jsonrpc.c">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="src\blade_transport_wss.c">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="src\blade_protocol.c">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="src\blade_rpc.c">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="src\include\unqlite.h">
@@ -71,14 +71,14 @@
     <ClInclude Include="src\include\blade_transport.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="src\include\blade_jsonrpc.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="src\include\blade_transport_wss.h">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="src\include\blade_protocol.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="src\include\blade_rpc.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
 </Project>
\ No newline at end of file

libs/libblade/src/blade_transport_wss.c

@@ -687,7 +687,7 @@ ks_status_t blade_transport_wss_onreceive(blade_connection_t *bc, cJSON **json)
 	return blade_transport_wss_link_read(btwssl, json);
 }
 
-ks_status_t blade_transport_wss_jsonrpc_error_send(blade_connection_t *bc, const char *id, int32_t code, const char *message)
+ks_status_t blade_transport_wss_rpc_error_send(blade_connection_t *bc, const char *id, int32_t code, const char *message)
 {
 	ks_status_t ret = KS_STATUS_SUCCESS;
 	blade_transport_wss_link_t *btwssl = NULL;
@@ -699,7 +699,7 @@ ks_status_t blade_transport_wss_jsonrpc_error_send(blade_connection_t *bc, const
 
 	btwssl = (blade_transport_wss_link_t *)blade_connection_transport_get(bc);
 
-	blade_jsonrpc_error_raw_create(&json, NULL, id, code, message);
+	blade_rpc_error_raw_create(&json, NULL, id, code, message);
 
     if (blade_transport_wss_link_write(btwssl, json) != KS_STATUS_SUCCESS) {
 		ks_log(KS_LOG_DEBUG, "Failed to write error message\n");
@@ -761,18 +761,18 @@ blade_connection_state_hook_t blade_transport_wss_onstate_startup_inbound(blade_
 
 	if (!json_req) {
 		ks_log(KS_LOG_DEBUG, "Failed to receive message before timeout\n");
-		blade_transport_wss_jsonrpc_error_send(bc, NULL, -32600, "Timeout while expecting request");
+		blade_transport_wss_rpc_error_send(bc, NULL, -32600, "Timeout while expecting request");
 		ret = BLADE_CONNECTION_STATE_HOOK_DISCONNECT;
 		goto done;
 	}
 
-	// @todo start here for a reusable handler for "blade.connect" request jsonrpc method within transport implementations,
+	// @todo start here for a reusable handler for "blade.connect" request rpc method within transport implementations,
 	// output 2 parameters for response and error, if an error occurs, send it, otherwise send the response
 
 	jsonrpc = cJSON_GetObjectCstr(json_req, "jsonrpc"); // @todo check for definitions of these keys and fixed values
 	if (!jsonrpc || strcmp(jsonrpc, "2.0")) {
 		ks_log(KS_LOG_DEBUG, "Received message is not the expected protocol\n");
-		blade_transport_wss_jsonrpc_error_send(bc, NULL, -32600, "Invalid request, missing 'jsonrpc' field");
+		blade_transport_wss_rpc_error_send(bc, NULL, -32600, "Invalid request, missing 'jsonrpc' field");
 		ret = BLADE_CONNECTION_STATE_HOOK_DISCONNECT;
 		goto done;
 	}
@@ -780,7 +780,7 @@ blade_connection_state_hook_t blade_transport_wss_onstate_startup_inbound(blade_
 	id = cJSON_GetObjectCstr(json_req, "id");
 	if (!id) {
 		ks_log(KS_LOG_DEBUG, "Received message is missing 'id'\n");
-		blade_transport_wss_jsonrpc_error_send(bc, NULL, -32600, "Invalid request, missing 'id' field");
+		blade_transport_wss_rpc_error_send(bc, NULL, -32600, "Invalid request, missing 'id' field");
 		ret = BLADE_CONNECTION_STATE_HOOK_DISCONNECT;
 		goto done;
 	}
@@ -788,7 +788,7 @@ blade_connection_state_hook_t blade_transport_wss_onstate_startup_inbound(blade_
 	method = cJSON_GetObjectCstr(json_req, "method");
 	if (!method || strcasecmp(method, "blade.connect")) {
 		ks_log(KS_LOG_DEBUG, "Received message is missing 'method' or is an unexpected method\n");
-		blade_transport_wss_jsonrpc_error_send(bc, id, -32601, "Missing or unexpected 'method' field");
+		blade_transport_wss_rpc_error_send(bc, id, -32601, "Missing or unexpected 'method' field");
 		ret = BLADE_CONNECTION_STATE_HOOK_DISCONNECT;
 		goto done;
 	}
@@ -826,7 +826,7 @@ blade_connection_state_hook_t blade_transport_wss_onstate_startup_inbound(blade_
 
 		if (blade_session_startup(bs) != KS_STATUS_SUCCESS) {
 			ks_log(KS_LOG_DEBUG, "Session (%s) startup failed\n", nodeid);
-			blade_transport_wss_jsonrpc_error_send(bc, id, -32603, "Internal error, session could not be started");
+			blade_transport_wss_rpc_error_send(bc, id, -32603, "Internal error, session could not be started");
 			blade_session_read_unlock(bs);
 			blade_session_destroy(&bs);
 			ret = BLADE_CONNECTION_STATE_HOOK_DISCONNECT;
@@ -863,7 +863,7 @@ blade_connection_state_hook_t blade_transport_wss_onstate_startup_inbound(blade_
 		ks_hash_read_unlock(realms);
 	}
 
-	blade_jsonrpc_response_raw_create(&json_res, &json_result, id);
+	blade_rpc_response_raw_create(&json_res, &json_result, id);
 	ks_assert(json_res);
 
 	cJSON_AddStringToObject(json_result, "nodeid", nodeid);
@@ -872,7 +872,7 @@ blade_connection_state_hook_t blade_transport_wss_onstate_startup_inbound(blade_
 	master_nodeid = blade_handle_master_nodeid_copy(bh, pool);
 	if (!master_nodeid) {
 		ks_log(KS_LOG_DEBUG, "Master nodeid unavailable\n");
-		blade_transport_wss_jsonrpc_error_send(bc, id, -32602, "Master nodeid unavailable");
+		blade_transport_wss_rpc_error_send(bc, id, -32602, "Master nodeid unavailable");
 		ret = BLADE_CONNECTION_STATE_HOOK_DISCONNECT;
 		goto done;
 	}
@@ -961,7 +961,7 @@ blade_connection_state_hook_t blade_transport_wss_onstate_startup_outbound(blade
 		goto done;
 	}
 
-	blade_jsonrpc_request_raw_create(pool, &json_req, &json_params, &mid, "blade.connect");
+	blade_rpc_request_raw_create(pool, &json_req, &json_params, &mid, "blade.connect");
 	ks_assert(json_req);
 
 	if (btwssl->session_id) cJSON_AddStringToObject(json_params, "session-id", btwssl->session_id);
@@ -988,7 +988,7 @@ blade_connection_state_hook_t blade_transport_wss_onstate_startup_outbound(blade
 		goto done;
 	}
 
-	// @todo start here for a reusable handler for "blade.connect" response jsonrpc method within transport implementations
+	// @todo start here for a reusable handler for "blade.connect" response rpc method within transport implementations
 
 	jsonrpc = cJSON_GetObjectCstr(json_res, "jsonrpc"); // @todo check for definitions of these keys and fixed values
 	if (!jsonrpc || strcmp(jsonrpc, "2.0")) {

libs/libblade/src/include/blade.h

@@ -41,7 +41,7 @@
 #include "blade_stack.h"
 #include "blade_identity.h"
 #include "blade_transport.h"
-#include "blade_jsonrpc.h"
+#include "blade_rpc.h"
 #include "blade_connection.h"
 #include "blade_session.h"
 #include "blade_protocol.h"

libs/libblade/src/include/blade_jsonrpc.h → libs/libblade/src/include/blade_rpc.h

@@ -31,46 +31,51 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef _BLADE_JSONRPC_H_
-#define _BLADE_JSONRPC_H_
+#ifndef _BLADE_RPC_H_
+#define _BLADE_RPC_H_
 #include <blade.h>
 
 KS_BEGIN_EXTERN_C
-KS_DECLARE(ks_status_t) blade_jsonrpc_create(blade_jsonrpc_t **bjsonrpcP, blade_handle_t *bh, const char *method, blade_jsonrpc_request_callback_t callback, void *callback_data);
-KS_DECLARE(ks_status_t) blade_jsonrpc_destroy(blade_jsonrpc_t **bjsonrpcP);
-KS_DECLARE(blade_handle_t *) blade_jsonrpc_handle_get(blade_jsonrpc_t *bjsonrpc);
-KS_DECLARE(const char *) blade_jsonrpc_method_get(blade_jsonrpc_t *bjsonrpc);
-KS_DECLARE(blade_jsonrpc_request_callback_t) blade_jsonrpc_callback_get(blade_jsonrpc_t *bjsonrpc);
-KS_DECLARE(void *) blade_jsonrpc_callback_data_get(blade_jsonrpc_t *bjsonrpc);
+KS_DECLARE(ks_status_t) blade_rpc_create(blade_rpc_t **brpcP, blade_handle_t *bh, const char *method, const char *protocol, const char *realm, blade_rpc_request_callback_t callback, void *callback_data);
+KS_DECLARE(ks_status_t) blade_rpc_destroy(blade_rpc_t **brpcP);
+KS_DECLARE(blade_handle_t *) blade_rpc_handle_get(blade_rpc_t *brpc);
+KS_DECLARE(const char *) blade_rpc_method_get(blade_rpc_t *brpc);
+KS_DECLARE(const char *) blade_rpc_protocol_get(blade_rpc_t *brpc);
+KS_DECLARE(const char *) blade_rpc_realm_get(blade_rpc_t *brpc);
+KS_DECLARE(blade_rpc_request_callback_t) blade_rpc_callback_get(blade_rpc_t *brpc);
+KS_DECLARE(void *) blade_rpc_callback_data_get(blade_rpc_t *brpc);
 
-KS_DECLARE(ks_status_t) blade_jsonrpc_request_create(blade_jsonrpc_request_t **bjsonrpcreqP,
+KS_DECLARE(ks_status_t) blade_rpc_request_create(blade_rpc_request_t **brpcreqP,
 													 blade_handle_t *bh,
 													 ks_pool_t *pool,
 													 const char *session_id,
 													 cJSON *json,
-													 blade_jsonrpc_response_callback_t callback);
-KS_DECLARE(ks_status_t) blade_jsonrpc_request_destroy(blade_jsonrpc_request_t **bjsonrpcreqP);
-KS_DECLARE(blade_handle_t *) blade_jsonrpc_request_handle_get(blade_jsonrpc_request_t *bjsonrpcreq);
-KS_DECLARE(const char *) blade_jsonrpc_request_sessionid_get(blade_jsonrpc_request_t *bjsonrpcreq);
-KS_DECLARE(cJSON *) blade_jsonrpc_request_message_get(blade_jsonrpc_request_t *bjsonrpcreq);
-KS_DECLARE(const char *) blade_jsonrpc_request_messageid_get(blade_jsonrpc_request_t *bjsonrpcreq);
-KS_DECLARE(blade_jsonrpc_response_callback_t) blade_jsonrpc_request_callback_get(blade_jsonrpc_request_t *bjsonrpcreq);
-KS_DECLARE(ks_status_t) blade_jsonrpc_request_raw_create(ks_pool_t *pool, cJSON **json, cJSON **params, const char **id, const char *method);
+													 blade_rpc_response_callback_t callback,
+													 void *data);
+KS_DECLARE(ks_status_t) blade_rpc_request_destroy(blade_rpc_request_t **brpcreqP);
+KS_DECLARE(blade_handle_t *) blade_rpc_request_handle_get(blade_rpc_request_t *brpcreq);
+KS_DECLARE(const char *) blade_rpc_request_sessionid_get(blade_rpc_request_t *brpcreq);
+KS_DECLARE(cJSON *) blade_rpc_request_message_get(blade_rpc_request_t *brpcreq);
+KS_DECLARE(const char *) blade_rpc_request_messageid_get(blade_rpc_request_t *brpcreq);
+KS_DECLARE(blade_rpc_response_callback_t) blade_rpc_request_callback_get(blade_rpc_request_t *brpcreq);
+KS_DECLARE(void *) blade_rpc_request_callback_data_get(blade_rpc_request_t *brpcreq);
 
-KS_DECLARE(ks_status_t) blade_jsonrpc_response_create(blade_jsonrpc_response_t **bjsonrpcresP,
+KS_DECLARE(ks_status_t) blade_rpc_request_raw_create(ks_pool_t *pool, cJSON **json, cJSON **params, const char **id, const char *method);
+
+KS_DECLARE(ks_status_t) blade_rpc_response_create(blade_rpc_response_t **brpcresP,
 													  blade_handle_t *bh,
 													  ks_pool_t *pool,
 													  const char *session_id,
-													  blade_jsonrpc_request_t *bjsonrpcreq,
+													  blade_rpc_request_t *brpcreq,
 													  cJSON *json);
-KS_DECLARE(ks_status_t) blade_jsonrpc_response_destroy(blade_jsonrpc_response_t **bjsonrpcresP);
-KS_DECLARE(ks_status_t) blade_jsonrpc_response_raw_create(cJSON **json, cJSON **result, const char *id);
-KS_DECLARE(blade_handle_t *) blade_jsonrpc_response_handle_get(blade_jsonrpc_response_t *bjsonrpcres);
-KS_DECLARE(const char *) blade_jsonrpc_response_sessionid_get(blade_jsonrpc_response_t *bjsonrpcres);
-KS_DECLARE(blade_jsonrpc_request_t *) blade_jsonrpc_response_request_get(blade_jsonrpc_response_t *bjsonrpcres);
-KS_DECLARE(cJSON *) blade_jsonrpc_response_message_get(blade_jsonrpc_response_t *bjsonrpcres);
+KS_DECLARE(ks_status_t) blade_rpc_response_destroy(blade_rpc_response_t **brpcresP);
+KS_DECLARE(ks_status_t) blade_rpc_response_raw_create(cJSON **json, cJSON **result, const char *id);
+KS_DECLARE(blade_handle_t *) blade_rpc_response_handle_get(blade_rpc_response_t *brpcres);
+KS_DECLARE(const char *) blade_rpc_response_sessionid_get(blade_rpc_response_t *brpcres);
+KS_DECLARE(blade_rpc_request_t *) blade_rpc_response_request_get(blade_rpc_response_t *brpcres);
+KS_DECLARE(cJSON *) blade_rpc_response_message_get(blade_rpc_response_t *brpcres);
 
-KS_DECLARE(ks_status_t) blade_jsonrpc_error_raw_create(cJSON **json, cJSON **error, const char *id, int32_t code, const char *message);
+KS_DECLARE(ks_status_t) blade_rpc_error_raw_create(cJSON **json, cJSON **error, const char *id, int32_t code, const char *message);
 KS_END_EXTERN_C
 
 #endif

libs/libblade/src/include/blade_session.h

@@ -62,7 +62,7 @@ KS_DECLARE(void) blade_session_hangup(blade_session_t *bs);
 KS_DECLARE(ks_bool_t) blade_session_terminating(blade_session_t *bs);
 KS_DECLARE(const char *) blade_session_connection_get(blade_session_t *bs);
 KS_DECLARE(ks_status_t) blade_session_connection_set(blade_session_t *bs, const char *id);
-KS_DECLARE(ks_status_t) blade_session_send(blade_session_t *bs, cJSON *json, blade_jsonrpc_response_callback_t callback);
+KS_DECLARE(ks_status_t) blade_session_send(blade_session_t *bs, cJSON *json, blade_rpc_response_callback_t callback, void *data);
 KS_DECLARE(ks_status_t) blade_session_sending_push(blade_session_t *bs, cJSON *json);
 KS_DECLARE(ks_status_t) blade_session_sending_pop(blade_session_t *bs, cJSON **json);
 KS_DECLARE(ks_status_t) blade_session_receiving_push(blade_session_t *bs, cJSON *json);

libs/libblade/src/include/blade_stack.h

@@ -66,13 +66,17 @@ KS_DECLARE(blade_session_t *) blade_handle_route_lookup(blade_handle_t *bh, cons
 KS_DECLARE(ks_status_t) blade_handle_transport_register(blade_transport_t *bt);
 KS_DECLARE(ks_status_t) blade_handle_transport_unregister(blade_transport_t *bt);
 
-KS_DECLARE(ks_status_t) blade_handle_jsonrpc_register(blade_jsonrpc_t *bjsonrpc);
-KS_DECLARE(ks_status_t) blade_handle_jsonrpc_unregister(blade_jsonrpc_t *bjsonrpc);
-KS_DECLARE(blade_jsonrpc_t *) blade_handle_jsonrpc_lookup(blade_handle_t *bh, const char *method);
+KS_DECLARE(ks_status_t) blade_handle_corerpc_register(blade_rpc_t *brpc);
+KS_DECLARE(ks_status_t) blade_handle_corerpc_unregister(blade_rpc_t *brpc);
+KS_DECLARE(blade_rpc_t *) blade_handle_corerpc_lookup(blade_handle_t *bh, const char *method);
 
-KS_DECLARE(ks_status_t) blade_handle_requests_add(blade_jsonrpc_request_t *bjsonrpcreq);
-KS_DECLARE(ks_status_t) blade_handle_requests_remove(blade_jsonrpc_request_t *bjsonrpcreq);
-KS_DECLARE(blade_jsonrpc_request_t *) blade_handle_requests_lookup(blade_handle_t *bh, const char *id);
+KS_DECLARE(ks_status_t) blade_handle_requests_add(blade_rpc_request_t *brpcreq);
+KS_DECLARE(ks_status_t) blade_handle_requests_remove(blade_rpc_request_t *brpcreq);
+KS_DECLARE(blade_rpc_request_t *) blade_handle_requests_lookup(blade_handle_t *bh, const char *id);
+
+KS_DECLARE(ks_status_t) blade_handle_protocolrpc_register(blade_rpc_t *brpc);
+KS_DECLARE(ks_status_t) blade_handle_protocolrpc_unregister(blade_rpc_t *brpc);
+KS_DECLARE(blade_rpc_t *) blade_handle_protocolrpc_lookup(blade_handle_t *bh, const char *method, const char *protocol, const char *realm);
 
 
 KS_DECLARE(ks_status_t) blade_handle_connect(blade_handle_t *bh, blade_connection_t **bcP, blade_identity_t *target, const char *session_id);
@@ -91,8 +95,15 @@ KS_DECLARE(ks_status_t) blade_handle_session_state_callback_register(blade_handl
 KS_DECLARE(ks_status_t) blade_handle_session_state_callback_unregister(blade_handle_t *bh, const char *id);
 KS_DECLARE(void) blade_handle_session_state_callbacks_execute(blade_session_t *bs, blade_session_state_condition_t condition);
 
-KS_DECLARE(ks_status_t) blade_protocol_publish(blade_handle_t *bh, const char *name, const char *realm);
-KS_DECLARE(ks_status_t) blade_protocol_locate(blade_handle_t *bh, const char *name, const char *realm);
+KS_DECLARE(ks_status_t) blade_protocol_publish(blade_handle_t *bh, const char *name, const char *realm, blade_rpc_response_callback_t callback, void *data);
+
+KS_DECLARE(ks_status_t) blade_protocol_locate(blade_handle_t *bh, const char *name, const char *realm, blade_rpc_response_callback_t callback, void *data);
+
+KS_DECLARE(ks_status_t) blade_protocol_execute(blade_handle_t *bh, const char *nodeid, const char *method, const char *protocol, const char *realm, cJSON *params, blade_rpc_response_callback_t callback, void *data);
+KS_DECLARE(cJSON *) blade_protocol_execute_request_params_get(blade_rpc_request_t *brpcreq);
+KS_DECLARE(cJSON *) blade_protocol_execute_response_result_get(blade_rpc_response_t *brpcres);
+KS_DECLARE(void) blade_protocol_execute_response_send(blade_rpc_request_t *brpcreq, cJSON *result);
+
 KS_END_EXTERN_C
 
 #endif

libs/libblade/src/include/blade_types.h

@@ -42,9 +42,9 @@ typedef struct blade_handle_s blade_handle_t;
 typedef struct blade_identity_s blade_identity_t;
 typedef struct blade_transport_s blade_transport_t;
 typedef struct blade_transport_callbacks_s blade_transport_callbacks_t;
-typedef struct blade_jsonrpc_s blade_jsonrpc_t;
-typedef struct blade_jsonrpc_request_s blade_jsonrpc_request_t;
-typedef struct blade_jsonrpc_response_s blade_jsonrpc_response_t;
+typedef struct blade_rpc_s blade_rpc_t;
+typedef struct blade_rpc_request_s blade_rpc_request_t;
+typedef struct blade_rpc_response_s blade_rpc_response_t;
 typedef struct blade_connection_s blade_connection_t;
 typedef struct blade_session_s blade_session_t;
 typedef struct blade_session_callbacks_s blade_session_callbacks_t;
@@ -53,8 +53,8 @@ typedef struct blade_protocol_realm_s blade_protocol_realm_t;
 typedef struct blade_protocol_method_s blade_protocol_method_t;
 
 
-typedef ks_bool_t (*blade_jsonrpc_request_callback_t)(blade_jsonrpc_request_t *breq, void *data);
-typedef ks_bool_t (*blade_jsonrpc_response_callback_t)(blade_jsonrpc_response_t *bres);
+typedef ks_bool_t (*blade_rpc_request_callback_t)(blade_rpc_request_t *brpcreq, void *data);
+typedef ks_bool_t (*blade_rpc_response_callback_t)(blade_rpc_response_t *brpcres, void *data);
 
 
 typedef enum {

libs/libblade/test/bladec.c

@@ -16,20 +16,98 @@ struct command_def_s {
 };
 
 void command_quit(blade_handle_t *bh, char *args);
-void command_connect(blade_handle_t *bh, char *args);
-//void command_chat(blade_handle_t *bh, char *args);
+void command_execute(blade_handle_t *bh, char *args);
 
 static const struct command_def_s command_defs[] = {
 	{ "quit", command_quit },
-	{ "connect", command_connect },
-//	{ "chat", command_chat },
+	{ "execute", command_execute },
 
 	{ NULL, NULL }
 };
 
-//ks_bool_t on_blade_chat_join_response(blade_response_t *bres);
-//ks_bool_t on_blade_chat_message_event(blade_event_t *bev);
-//void on_blade_session_state_callback(blade_session_t *bs, blade_session_state_condition_t condition, void *data);
+ks_bool_t test_echo_response_handler(blade_rpc_response_t *brpcres, void *data)
+{
+	blade_handle_t *bh = NULL;
+	blade_session_t *bs = NULL;
+	cJSON *result = NULL;
+	const char *text = NULL;
+
+	ks_assert(brpcres);
+
+	bh = blade_rpc_response_handle_get(brpcres);
+	ks_assert(bh);
+
+	bs = blade_handle_sessions_lookup(bh, blade_rpc_response_sessionid_get(brpcres));
+	ks_assert(bs);
+
+	result = blade_protocol_execute_response_result_get(brpcres);
+	ks_assert(result);
+
+	text = cJSON_GetObjectCstr(result, "text");
+	ks_assert(text);
+
+	ks_log(KS_LOG_DEBUG, "Session (%s) test.echo response processing\n", blade_session_id_get(bs));
+
+	blade_session_read_unlock(bs);
+
+	ks_log(KS_LOG_DEBUG, "Session (%s) test.echo: %s\n", blade_session_id_get(bs), text);
+
+	return KS_FALSE;
+}
+
+ks_bool_t blade_locate_response_handler(blade_rpc_response_t *brpcres, void *data)
+{
+	blade_handle_t *bh = NULL;
+	blade_session_t *bs = NULL;
+	const char *nodeid = NULL;
+	cJSON *res = NULL;
+	cJSON *res_result = NULL;
+	cJSON *res_result_providers = NULL;
+	const char *res_result_protocol = NULL;
+	const char *res_result_realm = NULL;
+	cJSON *params = NULL;
+
+	ks_assert(brpcres);
+
+	bh = blade_rpc_response_handle_get(brpcres);
+	ks_assert(bh);
+
+	bs = blade_handle_sessions_lookup(bh, blade_rpc_response_sessionid_get(brpcres));
+	ks_assert(bs);
+
+	res = blade_rpc_response_message_get(brpcres);
+	ks_assert(res);
+
+	res_result = cJSON_GetObjectItem(res, "result");
+	ks_assert(res_result);
+
+	res_result_protocol = cJSON_GetObjectCstr(res_result, "protocol");
+	ks_assert(res_result_protocol);
+	
+	res_result_realm = cJSON_GetObjectCstr(res_result, "realm");
+	ks_assert(res_result_realm);
+
+	res_result_providers = cJSON_GetObjectItem(res_result, "providers");
+	ks_assert(res_result_providers);
+
+	ks_log(KS_LOG_DEBUG, "Session (%s) blade.locate response processing\n", blade_session_id_get(bs));
+
+	for (int index = 0; index < cJSON_GetArraySize(res_result_providers); ++index) {
+		cJSON *elem = cJSON_GetArrayItem(res_result_providers, index);
+		if (elem->type == cJSON_String) {
+			ks_log(KS_LOG_DEBUG, "Session (%s) blade.locate (%s@%s) provider (%s)\n", blade_session_id_get(bs), res_result_protocol, res_result_realm, elem->valuestring);
+			nodeid = elem->valuestring;
+		}
+	}
+
+	blade_session_read_unlock(bs);
+
+	params = cJSON_CreateObject();
+	cJSON_AddStringToObject(params, "text", "hello world!");
+	blade_protocol_execute(bh, nodeid, "test.echo", res_result_protocol, res_result_realm, params, test_echo_response_handler, NULL);
+
+	return KS_FALSE;
+}
 
 int main(int argc, char **argv)
 {
@@ -71,9 +149,6 @@ int main(int argc, char **argv)
 		return EXIT_FAILURE;
 	}
 
-	//blade_handle_event_register(bh, "blade.chat.message", on_blade_chat_message_event);
-	//blade_handle_session_state_callback_register(bh, NULL, on_blade_session_state_callback, &session_state_callback_id);
-
 	if (autoconnect) {
 		blade_connection_t *bc = NULL;
 		blade_identity_t *target = NULL;
@@ -85,13 +160,9 @@ int main(int argc, char **argv)
 		blade_identity_destroy(&target);
 
 		ks_sleep_ms(5000);
-
-		blade_protocol_publish(bh, "test", "mydomain.com");
-
-		ks_sleep_ms(5000);
-	} else loop(bh);
-
-	//blade_handle_session_state_callback_unregister(bh, session_state_callback_id);
+	}
+	
+	loop(bh);
 
 	blade_handle_destroy(&bh);
 
@@ -102,38 +173,6 @@ int main(int argc, char **argv)
 	return 0;
 }
 
-//ks_bool_t on_blade_chat_message_event(blade_event_t *bev)
-//{
-//	cJSON *res = NULL;
-//	const char *from = NULL;
-//	const char *message = NULL;
-//
-//	ks_assert(bev);
-//
-//	res = cJSON_GetObjectItem(bev->message, "result");
-//	from = cJSON_GetObjectCstr(res, "from");
-//	message = cJSON_GetObjectCstr(res, "message");
-//
-//	ks_log(KS_LOG_DEBUG, "Received Chat Message Event: (%s) %s\n", from, message);
-//
-//	return KS_FALSE;
-//}
-//
-//void on_blade_session_state_callback(blade_session_t *bs, blade_session_state_condition_t condition, void *data)
-//{
-//	blade_session_state_t state = blade_session_state_get(bs);
-//
-//	if (condition == BLADE_SESSION_STATE_CONDITION_PRE) {
-//		ks_log(KS_LOG_DEBUG, "Blade Session State Changed: %s, %d\n", blade_session_id_get(bs), state);
-//		if (state == BLADE_SESSION_STATE_READY) {
-//			cJSON *req = NULL;
-//			blade_jsonrpc_request_raw_create(blade_handle_pool_get(blade_session_handle_get(bs)), &req, NULL, NULL, "blade.chat.join");
-//			blade_session_send(bs, req, on_blade_chat_join_response);
-//			cJSON_Delete(req);
-//		}
-//	}
-//}
-
 void loop(blade_handle_t *bh)
 {
 	char buf[CONSOLE_INPUT_MAX];
@@ -199,92 +238,21 @@ void command_quit(blade_handle_t *bh, char *args)
 	g_shutdown = KS_TRUE;
 }
 
-void command_connect(blade_handle_t *bh, char *args)
+void command_execute(blade_handle_t *bh, char *args)
 {
-	blade_connection_t *bc = NULL;
-	blade_identity_t *target = NULL;
-
 	ks_assert(bh);
 	ks_assert(args);
 
-	blade_identity_create(&target, blade_handle_pool_get(bh));
-
-	if (blade_identity_parse(target, args) == KS_STATUS_SUCCESS) blade_handle_connect(bh, &bc, target, NULL);
-
-	blade_identity_destroy(&target);
+	blade_protocol_locate(bh, "test", "mydomain.com", blade_locate_response_handler, NULL);
 }
 
-//ks_bool_t on_blade_chat_send_response(blade_response_t *bres);
-//
-//ks_bool_t on_blade_chat_join_response(blade_response_t *bres) // @todo this should get userdata passed in from when the callback is registered
-//{
-//	blade_session_t *bs = NULL;
-//	cJSON *req = NULL;
-//	cJSON *params = NULL;
-//
-//	ks_log(KS_LOG_DEBUG, "Received Chat Join Response!\n");
-//
-//	bs = blade_handle_sessions_get(bres->handle, bres->session_id);
-//	if (!bs) {
-//		ks_log(KS_LOG_DEBUG, "Unknown Session: %s\n", bres->session_id);
-//		return KS_FALSE;
-//	}
-//
-//	blade_jsonrpc_request_raw_create(blade_handle_pool_get(bres->handle), &req, &params, NULL, "blade.chat.send");
-//	ks_assert(req);
-//	ks_assert(params);
-//
-//	cJSON_AddStringToObject(params, "message", "Hello World!");
-//
-//	blade_session_send(bs, req, on_blade_chat_send_response);
-//
-//	blade_session_read_unlock(bs);
-//
-//	return KS_FALSE;
-//}
-//
-//ks_bool_t on_blade_chat_send_response(blade_response_t *bres) // @todo this should get userdata passed in from when the callback is registered
-//{
-//	ks_log(KS_LOG_DEBUG, "Received Chat Send Response!\n");
-//	return KS_FALSE;
-//}
-//
-//void command_chat(blade_handle_t *bh, char *args)
-//{
-//	char *cmd = NULL;
-//
-//	ks_assert(bh);
-//	ks_assert(args);
-//
-//	parse_argument(&args, &cmd, ' ');
-//	ks_log(KS_LOG_DEBUG, "Chat Command: %s, Args: %s\n", cmd, args);
-//
-//	if (!strcmp(cmd, "leave")) {
-//	} else if (!strcmp(cmd, "send")) {
-//		char *sid = NULL;
-//		blade_session_t *bs = NULL;
-//		cJSON *req = NULL;
-//		cJSON *params = NULL;
-//
-//		parse_argument(&args, &sid, ' ');
-//
-//		bs = blade_handle_sessions_get(bh, sid);
-//		if (!bs) {
-//			ks_log(KS_LOG_DEBUG, "Unknown Session: %s\n", sid);
-//			return;
-//		}
-//		blade_jsonrpc_request_raw_create(blade_handle_pool_get(bh), &req, &params, NULL, "blade.chat.send");
-//		ks_assert(req);
-//		ks_assert(params);
-//
-//		cJSON_AddStringToObject(params, "message", args);
-//
-//		blade_session_send(bs, req, on_blade_chat_send_response);
-//
-//		blade_session_read_unlock(bs);
-//
-//		cJSON_Delete(req);
-//	} else {
-//		ks_log(KS_LOG_DEBUG, "Unknown Chat Command: %s\n", cmd);
-//	}
-//}
+/* For Emacs:
+* Local Variables:
+* mode:c
+* indent-tabs-mode:t
+* tab-width:4
+* c-basic-offset:4
+* End:
+* For VIM:
+* vim:set softtabstop=4 shiftwidth=4 tabstop=4 noet:
+*/