private static IEnumerable <DataFrame> ReadFrames(IDataAdapter client, DynamicScriptContainer container, Logger logger, object config)
{
DataReader reader = new DataReader(new DataAdapterToStream(client));
while (!reader.Eof)
{
DynamicStreamDataKey2 key = new DynamicStreamDataKey2("Root", container, logger, config);
try
{
key.FromReader(reader);
}
catch (ThreadAbortException)
{
throw;
}
catch (EndOfStreamException)
{
// End of stream, do nothing
}
catch (Exception e)
{
logger.LogException(e);
yield break;
}
// Only fill in the frame if we read something, should this exit if it continues to read nothing?
if (reader.ByteCount > 0)
{
yield return(new DataFrame(key));
}
}
}
/// <summary>
/// Create the layer
/// </summary>
/// <param name="logger">The logger to use when creating</param>
/// <returns>The network layer</returns>
public override INetworkLayer CreateLayer(Logger logger)
{
if (Script == null)
{
throw new InvalidOperationException(String.Format(Properties.Resources.ScriptNetworkLayerFactory_SpecifyScript, Description));
}
if (ClassName == null)
{
throw new InvalidOperationException(String.Format(Properties.Resources.ScriptNetworkLayerFactory_SpecifyClassName, Description));
}
object obj = Script.Container.GetInstance(ClassName);
INetworkLayer layer = obj as INetworkLayer;
if (layer == null)
{
IDataStreamParser parser = obj as IDataStreamParser;
if (parser != null)
{
layer = new ParserNetworkLayer(DynamicScriptContainer.Create(Script.Container, ClassName), logger);
}
}
if (layer == null)
{
throw new InvalidOperationException(String.Format(Properties.Resources.ScriptNetworkLayerFactory_InvalidType, Script.Name));
}
IPersistNode persist = layer as IPersistNode;
if (persist != null)
{
persist.SetState(new DynamicConfigObject(_config), logger);
}
return(layer);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
protected override BasePipelineNode OnCreate(Logger logger, NetGraph graph, Dictionary <string, object> stateDictionary)
{
BasePipelineNode node = null;
if (Container != null)
{
try
{
if (String.IsNullOrWhiteSpace(ClassName))
{
throw new ArgumentException(String.Format(CANAPE.Scripting.Properties.Resources.DynamicNodeFactory_MustSpecifyClassName, Label));
}
// Determine what type of object we create, if it is an BasePipelineNode then return as is,
// if it is a parser then create the parsing pipeline node to contain it
object o = ScriptUtils.GetInstance(Container, ClassName);
if (o is BasePipelineNode)
{
node = o as BasePipelineNode;
if (State != null)
{
IPersistNode persist = node as IPersistNode;
if (persist != null)
{
persist.SetState(State, logger);
}
}
}
else if (o is IDataStreamParser)
{
// If we are selecting the whole packet, then we convert a binary stream
if (SelectionPath == "/")
{
DynamicBinaryStreamPipelineNode stmNode = new DynamicBinaryStreamPipelineNode();
stmNode.Container = DynamicScriptContainer.Create(Container, ClassName);
stmNode.State = State;
node = stmNode;
}
else
{
DynamicStreamPipelineNode dynNode = new DynamicStreamPipelineNode();
dynNode.Container = DynamicScriptContainer.Create(Container, ClassName);
dynNode.State = State;
node = dynNode;
}
}
else if (o is IDataArrayParser)
{
DynamicArrayPipelineNode dynNode = new DynamicArrayPipelineNode();
dynNode.Container = DynamicScriptContainer.Create(Container, ClassName);
dynNode.State = State;
node = dynNode;
}
else if (o is IDataStringParser)
{
DynamicStringPipelineNode dynNode = new DynamicStringPipelineNode();
dynNode.Container = DynamicScriptContainer.Create(Container, ClassName);
dynNode.State = State;
node = dynNode;
}
else if (o == null)
{
throw new InvalidOperationException(String.Format(CANAPE.Scripting.Properties.Resources.DynamicNodeFactory_CannotCreateType, ClassName, Label));
}
else
{
throw new InvalidOperationException(String.Format(CANAPE.Scripting.Properties.Resources.DynamicNodeFactory_InvalidNodeType, o.GetType().Name, Label));
}
node.Enabled = Enabled;
}
catch (EndOfStreamException)
{
// End of stream
}
catch (ThreadAbortException)
{
}
}
else
{
throw new ArgumentException(String.Format(CANAPE.Scripting.Properties.Resources.DynamicNodeFactory_NoScriptSpecified, Label));
}
return(node);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="container">The script container for both directions</param>
/// <param name="logger">Logger to log output</param>
public ParserNetworkLayer(DynamicScriptContainer container, Logger logger)
: this(container, container, logger)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="clientContainer">The script container for the client sourced packets</param>
/// <param name="serverContainer">The script container for the server sourced packets</param>
/// <param name="logger">Logger to log output</param>
public ParserNetworkLayer(DynamicScriptContainer clientContainer, DynamicScriptContainer serverContainer, Logger logger)
{
_clientContainer = clientContainer;
_serverContainer = serverContainer;
_logger = logger;
}
