private void HandleMessage(string message, ClientConnection connection)
{
if ((message == null) || ((message = message.Trim()).Length == 0) ||
(connection == null) || (!connection.connected))
return;
NetworkDevice clientDevice = connection.clientDevice;
Message response = null;
try
{
logger.Log("Handling incoming message:\n" + message);
object json = Json.Deserialize(message);
string type = Util.JsonOptString(json as IDictionary<string, object>, "type");
if (type != null)
{
Message.Type messageType = (Message.Type)System.Enum.Parse(typeof(Message.Type), type, true);
switch (messageType)
{
case Message.Type.SERVICE_CALL_REQUEST:
logger.Log("Incoming Service Call");
CallContext messageContext = new CallContext();
messageContext.callerNetworkDevice = clientDevice;
response = HandleServiceCall(message, messageContext);
break;
case Message.Type.NOTIFY:
logger.Log("Incoming Notify");
HandleNotify(message, clientDevice);
break;
default:
break;
}
}
}
catch (System.Exception ex)
{
PushLog("Failure to handle the incoming message. ", ex);
response = new Notify();
response.error = "Failure to handle the incoming message. ";
}
if (response != null)
{
string msg = Json.Serialize(response.ToJSON()) + "\n";
byte[] bytes = Encoding.UTF8.GetBytes(msg);
try
{
connection.Write(bytes, 0, bytes.Length);
PushLog("Responded successfully.");
}
catch (System.Exception e)
{
PushLog("Error while responding. ", e);
}
}
}
private void HandleStreamCall(Call serviceCall, CallContext messageContext)
{
if (serviceCall.serviceType == ServiceType.STREAM)
{
NetworkDevice networkDevice = messageContext.callerNetworkDevice;
string host = Util.GetHost(networkDevice.networkDeviceName);
for (int i = 0; i < serviceCall.channels; i++)
{
ClientConnection con = gateway.OpenActiveConnection(host + ":" + serviceCall.channelIDs[i], serviceCall.channelType);
messageContext.AddConnection(con);
}
}
}
public void Handshake(Call serviceCall, Response serviceResponse, CallContext messageContext)
{
string deviceParameter = serviceCall.GetParameterString(DEVICE_KEY);
if (deviceParameter == null)
{
serviceResponse.error = "No 'device' parameter informed.";
return;
}
try
{
UpDevice device = UpDevice.FromJSON(Json.Deserialize(deviceParameter));
gateway.deviceManager.RegisterDevice(device);
serviceResponse.AddParameter(DEVICE_KEY, Json.Serialize(gateway.currentDevice.ToJSON()));
//TODO: actually implement the driver register for other devices...
//Response driversResponse = gateway.CallService(device, new Call("uos.DeviceDriver", "listDrivers"));
//object driverList = driversResponse.GetResponseData("driverList");
//if (driverList != null)
//{
// var driverMap = (IDictionary<string, object>)Json.Deserialize(driverList.ToString());
// // TODO: this is duplicated with DeviceManager.registerRemoteDriverInstances
// foreach (string id in driverMap.Keys)
// {
// UpDriver upDriver = UpDriver.FromJSON(Json.Deserialize(driverMap[id].ToString()));
// DriverModel driverModel = new DriverModel(id, upDriver, device.name);
// gateway.driverManager.Insert(driverModel);
// }
//}
}
catch (System.Exception e)
{
serviceResponse.error = e.Message;
logger.LogError("Problems on handshake: " + e.Message + "," + e.StackTrace);
}
}
public Response CallService(object instance, Call call, CallContext context)
{
MethodInfo method = FindMethod(call, instance);
if (method != null)
{
logger.Log(
"Calling service '" + call.service + "' of driver '" + call.driver + "' on instance '" + call.instanceId + "'");
HandleStreamCall(call, context);
Response response = new Response();
method.Invoke(instance, new object[] { call, response, context });
logger.Log("Finished service call.");
return response;
}
else
throw new System.Exception(
"No Service Implementation found for service '" + call.service +
"' on driver '" + call.driver + "' with id '" + call.instanceId + "'.");
}
public void Goodbye(Call serviceCall, Response serviceResponse, CallContext messageContext)
{
gateway.deviceManager.DeviceLeft(messageContext.callerNetworkDevice);
}
/// <summary>
/// This method is responsible for informing the unknown equivalent driverss.
/// </summary>
/// <param name="serviceCall"></param>
/// <param name="serviceResponse"></param>
/// <param name="messageContext"></param>
public void TellEquivalentDrivers(Call serviceCall, Response serviceResponse, CallContext messageContext)
{
try
{
string equivalentDrivers = serviceCall.GetParameterString(DRIVERS_NAME_KEY);
IList<object> equivalentDriversJson = Json.Deserialize(equivalentDrivers) as IList<object>;
List<object> jsonList = new List<object>();
IDictionary<string, object> responseData = new Dictionary<string, object>();
for (int i = 0; i < equivalentDriversJson.Count; i++)
{
string equivalentDriver = equivalentDriversJson[i] as string;
UpDriver driver = gateway.driverManager.GetDriverFromEquivalanceTree(equivalentDriver);
if (driver != null)
AddToEquivalanceList(jsonList, driver);
}
responseData[INTERFACES_KEY] = Json.Serialize(jsonList);
serviceResponse.responseData = responseData;
}
catch (System.Exception e)
{
logger.LogError("Problems on equivalent drivers. " + e.StackTrace);
}
}
public void ListDrivers(Call serviceCall, Response serviceResponse, CallContext messageContext)
{
logger.Log("Handling DeviceDriverImpl#listDrivers service");
try
{
IDictionary<string, object> parameters = serviceCall.parameters;
DriverManager driverManager = gateway.driverManager;
// Handles parameters to filter message...
IList<DriverData> listDrivers =
driverManager.ListDrivers(
((parameters != null) ? (parameters[DRIVER_NAME_KEY] as string) : null),
gateway.currentDevice.name
);
IDictionary<string, object> driversList = new Dictionary<string, object>();
if ((listDrivers != null) && (listDrivers.Count > 0))
{
foreach (var driver in listDrivers)
driversList[driver.instanceID] = driver.driver.ToJSON();
}
IDictionary<string, object> responseData = new Dictionary<string, object>();
responseData[DRIVER_LIST_KEY] = driversList;
serviceResponse.responseData = responseData;
}
catch (System.Exception e)
{
serviceResponse.error = e.Message;
logger.LogError("Problem on ListDrivers service: " + e.Message + "," + e.StackTrace);
}
}
private Response HandleServiceCall(string message, CallContext messageContext)
{
try
{
Call serviceCall = Call.FromJSON(Json.Deserialize(message));
Response response = gateway.HandleServiceCall(serviceCall, messageContext);
logger.Log("Returning service response");
return response;
}
catch (System.Exception e)
{
PushLog("Internal Failure: ", e);
Response errorResponse = new Response();
errorResponse.error = e.Message == null ? "Internal Error" : e.Message;
return errorResponse;
}
}
/// <summary>
/// Calls a service and waits for response.
/// </summary>
/// <param name="device"></param>
/// <param name="serviceCall"></param>
/// <returns></returns>
public Response CallService(UpDevice device, Call serviceCall)
{
if (
(serviceCall == null) ||
(serviceCall.driver == null) || (serviceCall.driver.Length == 0) ||
(serviceCall.service == null) || (serviceCall.service.Length == 0))
throw new System.ArgumentException("Service Driver or Service Name is empty");
StreamConnectionThreadData[] streamConData = null;
CallContext messageContext = new CallContext();
messageContext.callerNetworkDevice = new LoopbackDevice(1);
// In case of a Stream Service, a Stream Channel must be opened
if (serviceCall.serviceType == ServiceType.STREAM)
streamConData = OpenStreamChannel(device, serviceCall, messageContext);
if (IsLocalCall(device))
return LocalServiceCall(serviceCall, streamConData, messageContext);
else
return RemoteServiceCall(device, serviceCall, streamConData, messageContext);
}
public StreamConnectionThreadData(UnityGateway gateway, CallContext msgContext, NetworkDevice networkDevice)
{
this.gateway = gateway;
this.thread = new Thread(new ThreadStart(Run));
this.msgContext = msgContext;
this.networkDevice = networkDevice;
}
private Response RemoteServiceCall(
UpDevice target,
Call serviceCall,
StreamConnectionThreadData[] streamData,
CallContext messageContext)
{
try
{
logger.Log("Call service on " + target.name + ": " + Json.Serialize(serviceCall.ToJSON()));
// Encodes and sends call message.
string msg = Json.Serialize(serviceCall.ToJSON()) + "\n";
Response r;
string responseMsg = SendMessage(msg, target);
if (responseMsg != null)
{
r = Response.FromJSON(Json.Deserialize(responseMsg));
r.messageContext = messageContext;
return r;
}
else
throw new System.Exception("No response received from call.");
}
catch (System.Exception e)
{
logger.LogError("Error on remote service call: " + e.ToString());
CloseStreams(streamData);
throw new ServiceCallException(e);
}
}
private StreamConnectionThreadData[] OpenStreamChannel(UpDevice device, Call serviceCall, CallContext messageContext)
{
StreamConnectionThreadData[] data = null;
//Channel type decision
string netType = null;
if (serviceCall.channelType != null)
netType = serviceCall.channelType;
else
{
UpNetworkInterface network = GetAppropriateInterface(device);
netType = network.netType;
}
int channels = serviceCall.channels;
data = new StreamConnectionThreadData[channels];
string[] channelIDs = new string[channels];
for (int i = 0; i < channels; i++)
{
NetworkDevice networkDevice = GetAvailableNetworkDevice(netType);
channelIDs[i] = Util.GetPort(networkDevice.networkDeviceName);
StreamConnectionThreadData thread = new StreamConnectionThreadData(this, messageContext, networkDevice);
thread.thread.Start();
data[i] = thread;
}
serviceCall.channelIDs = channelIDs;
serviceCall.channelType = netType;
return data;
}
private Response LocalServiceCall(
Call serviceCall,
StreamConnectionThreadData[] streamData,
CallContext messageContext)
{
logger.Log("Handling Local ServiceCall");
try
{
Response response = HandleServiceCall(serviceCall, messageContext);
response.messageContext = messageContext;
return response;
}
catch (System.Exception e)
{
// if there was an opened stream channel, it must be closed
CloseStreams(streamData);
throw new ServiceCallException(e);
}
}
public Response HandleServiceCall(Call serviceCall, CallContext messageContext)
{
NetworkDevice netDevice = messageContext.callerNetworkDevice;
if (netDevice != null)
{
if (netDevice is LoopbackDevice)
messageContext.callerDevice = currentDevice;
else
{
string addr = Util.GetHost(netDevice.networkDeviceName);
string type = netDevice.networkDeviceType;
messageContext.callerDevice = deviceManager.RetrieveDevice(addr, type);
}
}
if (IsApplicationCall(serviceCall))
{
if (app == null)
throw new System.InvalidOperationException("No valid app instance set.");
return reflectionServiceCaller.CallService(app, serviceCall, messageContext);
}
else
return driverManager.HandleServiceCall(serviceCall, messageContext);
}
public Response HandleServiceCall(Call serviceCall, CallContext messageContext)
{
//Handle named InstanceCall
DriverModel model = null;
if (serviceCall.instanceId != null)
{
//Find DriversInstance
lock (_driverdao_lock) { model = driverDao.Retrieve(serviceCall.instanceId, currentDevice.name); }
if (model == null)
{
logger.LogError("No Instance found with id '" + serviceCall.instanceId + "'");
throw new System.Exception("No Instance found with id '" + serviceCall.instanceId + "'");
}
}
else
{
//Handle non-named InstanceCall
List<DriverModel> list;
lock (_driverdao_lock) { list = driverDao.List(serviceCall.driver, currentDevice.name); }
//Tries to find an equivalent driver...
if ((list == null) || (list.Count == 0))
{
TreeNode driverNode = null;
if (!driverHash.TryGetValue(serviceCall.driver, out driverNode))
{
logger.Log("No instance found for handling driver '" + serviceCall.driver + "'");
throw new System.Exception("No instance found for handling driver '" + serviceCall.driver + "'");
}
list = FindEquivalentDriver(driverNode.children);
if ((list == null) || (list.Count == 0))
{
logger.Log("No instance found for handling driver '" + serviceCall.driver + "'");
throw new System.Exception("No instance found for handling driver '" + serviceCall.driver + "'");
}
}
// Select the first driver found (since no specific instance was informed)
model = list[0];
}
return gateway.reflectionServiceCaller.CallService(instances[model.rowid], serviceCall, messageContext);
}
