/// <summary>The return value from executing the Erlang RPC.</summary>
/// <param name="module">The module to call</param>
/// <param name="function">The function to invoke</param>
/// <param name="erlangObject">The erlang object that is passed in as a parameter</param>
/// <returns>The converted .NET object return value from the RPC call.</returns>
/// <exception cref="ErlangConversionException">in case of conversion failures</exception>
public override object FromErlangRpc(string module, string function, OtpErlangObject erlangObject)
{
var converter = this.GetConverter(module, function);
if (converter != null)
{
return(converter.FromErlang(erlangObject));
}
else
{
return(base.FromErlangRpc(module, function, erlangObject));
}
}
/// <summary>Extracts the string.</summary>
/// <param name="obj">The obj.</param>
/// <returns>The string.</returns>
private string ExtractString(OtpErlangObject obj)
{
if (obj is OtpErlangBinary)
{
var binary = (OtpErlangBinary)obj;
return(new UTF8Encoding().GetString(binary.binaryValue()));
}
else if (obj is OtpErlangTuple)
{
var tuple = (OtpErlangTuple)obj;
return(this.ExtractString(tuple.elementAt(0)));
}
return(null);
}
/// <summary>Convert from an Erlang data type to a .NET data type.</summary>
/// <param name="erlangObject">The erlang object.</param>
/// <returns>The converted .NET object</returns>
/// <exception cref="ErlangConversionException">in case of conversion failures</exception>
public override object FromErlang(OtpErlangObject erlangObject)
{
var applications = new List <Application>();
var nodes = new List <Node>();
var runningNodes = new List <Node>();
if (erlangObject is OtpErlangList)
{
var erlangList = (OtpErlangList)erlangObject;
var runningAppTuple = (OtpErlangTuple)erlangList.elementAt(1);
var appList = (OtpErlangList)runningAppTuple.elementAt(1);
this.ExtractApplications(applications, appList);
}
return(new RabbitStatus(applications, nodes, runningNodes));
}
/// <summary>Convert from an Erlang data type to a .NET data type.</summary>
/// <param name="erlangObject">The erlang object.</param>
/// <returns>The converted .NET object</returns>
/// <exception cref="ErlangConversionException">in case of conversion failures</exception>
public override object FromErlang(OtpErlangObject erlangObject)
{
var users = new List <string>();
if (erlangObject is OtpErlangList)
{
var erlangList = (OtpErlangList)erlangObject;
foreach (var obj in erlangList)
{
if (obj is OtpErlangList)
{
var value = this.ExtractString(((OtpErlangTuple)((OtpErlangList)obj).elementAt(0)).elementAt(1));
if (value != null)
{
users.Add(value);
}
}
}
}
return(users);
}
/// <summary>Handles the response error.</summary>
/// <param name="module">The module.</param>
/// <param name="function">The function.</param>
/// <param name="result">The result.</param>
public void HandleResponseError(string module, string function, OtpErlangObject result)
{
/* {badrpc,{'EXIT',{undef,[{rabbit_access_control,list_users,[[]]},{rpc,'-handle_call/3-fun-0-',5}]}}} */
if (result is OtpErlangTuple)
{
var msg = (OtpErlangTuple)result;
if (msg.elementAt(0) is OtpErlangAtom)
{
var responseAtom = (OtpErlangAtom)msg.elementAt(0);
// TODO: consider error handler strategy.
if (responseAtom.atomValue().Equals("badrpc"))
{
if (msg.elementAt(1) is OtpErlangTuple)
{
throw new ErlangBadRpcException((OtpErlangTuple)msg.elementAt(1));
}
else
{
throw new ErlangBadRpcException(msg.elementAt(1).ToString());
}
}
else if (responseAtom.atomValue().Equals("error"))
{
if (msg.elementAt(1) is OtpErlangTuple)
{
throw new ErlangErrorRpcException((OtpErlangTuple)msg.elementAt(1));
}
else
{
throw new ErlangErrorRpcException(msg.elementAt(1).ToString());
}
}
}
}
}
/// <summary>The return value from executing the Erlang RPC.</summary>
/// <param name="module">The module to call</param>
/// <param name="function">The function to invoke</param>
/// <param name="erlangObject">The erlang object that is passed in as a parameter</param>
/// <returns>The converted .NET object return value from the RPC call.</returns>
/// <exception cref="ErlangConversionException">in case of conversion failures</exception>
public virtual object FromErlangRpc(string module, string function, OtpErlangObject erlangObject)
{
return(this.FromErlang(erlangObject));
}
/// <summary>Convert from an Erlang data type to a .NET data type.</summary>
/// <param name="erlangObject">The erlang object.</param>
/// <returns>The converted .NET object</returns>
/// <exception cref="ErlangConversionException">in case of conversion failures</exception>
public virtual object FromErlang(OtpErlangObject erlangObject)
{
// TODO: support arrays
return(this.ConvertErlangToBasicType(erlangObject));
}
/// <summary>Extracts the long.</summary>
/// <param name="value">The value.</param>
/// <returns>The long.</returns>
public static long ExtractLong(OtpErlangObject value)
{
return(((OtpErlangLong)value).longValue());
}
/// <summary>The extract pid.</summary>
/// <param name="value">The value.</param>
/// <returns>The System.String.</returns>
public static string ExtractPid(OtpErlangObject value)
{
return(value.ToString());
}
/// <summary>Extracts the boolean.</summary>
/// <param name="erlangObject">The erlang object.</param>
/// <returns>The boolean.</returns>
public static bool ExtractBoolean(OtpErlangObject erlangObject)
{
// TODO Erlang.NET has wrong capitilization
return(((OtpErlangBoolean)erlangObject).boolValue());
}
/// <summary>Converts the type of the erlang to basic.</summary>
/// <param name="erlangObject">The erlang object.</param>
/// <returns>The object.</returns>
private object ConvertErlangToBasicType(OtpErlangObject erlangObject)
{
try
{
if (erlangObject is OtpErlangBinary)
{
return(((OtpErlangBinary)erlangObject).binaryValue());
}
else if (erlangObject is OtpErlangAtom)
{
return(((OtpErlangAtom)erlangObject).atomValue());
}
else if (erlangObject is OtpErlangBinary)
{
return(((OtpErlangBinary)erlangObject).binaryValue());
}
else if (erlangObject is OtpErlangBoolean)
{
return(ExtractBoolean(erlangObject));
}
else if (erlangObject is OtpErlangByte)
{
return(((OtpErlangByte)erlangObject).byteValue());
}
else if (erlangObject is OtpErlangChar)
{
return(((OtpErlangChar)erlangObject).charValue());
}
else if (erlangObject is OtpErlangDouble)
{
return(((OtpErlangDouble)erlangObject).doubleValue());
}
else if (erlangObject is OtpErlangFloat)
{
return(((OtpErlangFloat)erlangObject).floatValue());
}
else if (erlangObject is OtpErlangInt)
{
return(((OtpErlangInt)erlangObject).intValue());
}
else if (erlangObject is OtpErlangLong)
{
return(((OtpErlangLong)erlangObject).longValue());
}
else if (erlangObject is OtpErlangShort)
{
return(((OtpErlangShort)erlangObject).shortValue());
}
else if (erlangObject is OtpErlangString)
{
return(((OtpErlangString)erlangObject).stringValue());
}
else if (erlangObject is OtpErlangPid)
{
return(erlangObject.ToString());
}
else
{
throw new ErlangConversionException(
"Could not convert Erlang object ["
+ erlangObject.GetType() + "] to .NET type.");
}
}
catch (OtpErlangRangeException ex)
{
// TODO: Erlang.NET exceptions do not support nesting root exceptions.
throw new ErlangConversionException(
"Could not convert Erlang object [" + erlangObject.GetType()
+ "] to .NET type. OtpErlangRangeException msg [" + ex.Message +
"]");
}
}
/// <summary>Extracts the atom boolean.</summary>
/// <param name="value">The value.</param>
/// <returns>The atom boolean.</returns>
private bool ExtractAtomBoolean(OtpErlangObject value)
{
return(((OtpErlangAtom)value).boolValue());
}
/// <summary>The from erlang.</summary>
/// <param name="erlangObject">The erlang object.</param>
/// <returns>The System.Object.</returns>
public override object FromErlang(OtpErlangObject erlangObject)
{
var queueInfoList = new List <QueueInfo>();
if (erlangObject is OtpErlangList)
{
var erlangList = (OtpErlangList)erlangObject;
foreach (var element in erlangList)
{
var queueInfo = new QueueInfo();
var itemList = (OtpErlangList)element;
foreach (var item in itemList)
{
var tuple = (OtpErlangTuple)item;
if (tuple.arity() == 2)
{
var key = tuple.elementAt(0).ToString();
var value = tuple.elementAt(1);
switch (ToQueueInfoField(key))
{
case QueueInfoField.name:
queueInfo.Name = this.ExtractNameValueFromTuple((OtpErlangTuple)value);
break;
case QueueInfoField.transactions:
queueInfo.Transactions = ExtractLong(value);
break;
case QueueInfoField.acks_uncommitted:
queueInfo.AcksUncommitted = ExtractLong(value);
break;
case QueueInfoField.consumers:
queueInfo.Consumers = ExtractLong(value);
break;
case QueueInfoField.pid:
queueInfo.Pid = ExtractPid(value);
break;
case QueueInfoField.durable:
queueInfo.Durable = this.ExtractAtomBoolean(value);
break;
case QueueInfoField.messages:
queueInfo.Messages = ExtractLong(value);
break;
case QueueInfoField.memory:
queueInfo.Memory = ExtractLong(value);
break;
case QueueInfoField.auto_delete:
queueInfo.AutoDelete = this.ExtractAtomBoolean(value);
break;
case QueueInfoField.messages_ready:
queueInfo.MessagesReady = ExtractLong(value);
break;
case QueueInfoField.arguments:
var list = (OtpErlangList)value;
if (list != null)
{
var args = new string[list.arity()];
for (var i = 0; i < list.arity(); i++)
{
var obj = list.elementAt(i);
args[i] = obj.ToString();
}
queueInfo.Arguments = args;
}
break;
case QueueInfoField.messages_unacknowledged:
queueInfo.MessagesUnacknowledged = ExtractLong(value);
break;
case QueueInfoField.messages_uncommitted:
queueInfo.MessageUncommitted = ExtractLong(value);
break;
default:
break;
}
}
}
queueInfoList.Add(queueInfo);
}
}
return(queueInfoList);
}
