public static IChannel Create(ChannelSettings channelSettings, DirectoryInfo workingDirectory)
{
if (channelSettings == null)
{
throw new ArgumentNullException(nameof(channelSettings));
}
if (workingDirectory == null)
{
throw new ArgumentNullException(nameof(workingDirectory));
}
ChannelDirection channelDirection = channelSettings.GetType() == typeof(FromSettings) ? ChannelDirection.Inbound : ChannelDirection.Outbound;
switch (channelSettings.Type)
{
case ConfigChannelType.Local:
{
return(new LocalChannel(workingDirectory, channelSettings));
}
case ConfigChannelType.Sftp:
{
return(new SftpChannel(workingDirectory, channelSettings));
}
default:
{
throw new InvalidOperationException($"There is no corresponding channel type for '{channelSettings.Type}'.");
}
}
}
/// <summary>
/// This is the base constructor.
/// </summary>
/// <param name="context">This is the api context.</param>
/// <param name="direction">The event direction.</param>
/// <param name="level">This enumeration determines which part of the data should be logged.</param>
public ApiBoundaryEvent(HttpActionExecutedContext context, ChannelDirection direction, ApiBoundaryLoggingFilterLevel level)
{
Level = level;
mContext = context;
Direction = direction;
Type = BoundaryEventType.Boundary;
Id = Guid.NewGuid();
if ((level & ApiBoundaryLoggingFilterLevel.Exception) > 0)
{
Ex = context.Exception;
}
if ((level & ApiBoundaryLoggingFilterLevel.Request) > 0)
{
Request = new HttpRequestWrapper(context);
}
if ((level & ApiBoundaryLoggingFilterLevel.Response) > 0)
{
Response = new HttpResponseWrapper(context);
}
if ((level & ApiBoundaryLoggingFilterLevel.RequestContent) > 0)
{
RequestBody = new ApiMimeContent(context.Request.Content);
}
if ((level & ApiBoundaryLoggingFilterLevel.ResponseContent) > 0)
{
ResponseBody = new ApiMimeContent(context.Response.Content);
}
}
/// <summary>
/// This method attempts to retrieve and existing channel.
/// </summary>
/// <param name="channelId">The channel Id.</param>
/// <param name="direction">The direction.</param>
/// <param name="channel">Returns the channel object.</param>
/// <returns></returns>
public bool TryGet(string channelId, ChannelDirection direction, out Channel channel)
{
channel = null;
if ((direction & ChannelDirection.Incoming) > 0
& mContainerIncoming.TryGetValue(channelId, out channel))
{
return(true);
}
if ((direction & ChannelDirection.Outgoing) > 0
& mContainerOutgoing.TryGetValue(channelId, out channel))
{
return(true);
}
if (mPolicy.AutoCreateChannels)
{
channel = new Channel(channelId, direction, isAutocreated: true);
Add(channel);
return(true);
}
return(false);
}
/// <summary>
/// This helper resolves a channel from the direction specified.
/// </summary>
/// <param name="cpipe">The pipeline.</param>
/// <param name="direction"></param>
/// <param name="throwIfChannelIsNull"></param>
/// <returns>The resolved channel or null if not resolved and throwIfChannelIsNull is false. Otherwise an exception will be raised.</returns>
public static Channel ToChannel(this IPipelineChannel cpipe, ChannelDirection direction, bool throwIfChannelIsNull = true)
{
Channel channel = null;
if (cpipe is IPipelineChannelBroadcast)
{
switch (direction)
{
case ChannelDirection.Incoming:
channel = ((IPipelineChannelBroadcast)cpipe).ChannelListener;
break;
case ChannelDirection.Outgoing:
channel = ((IPipelineChannelBroadcast)cpipe).ChannelSender;
break;
default:
throw new NotSupportedException($"ChannelDirection {direction} not supported in {nameof(CorePipelineExtensions)}/{nameof(ToChannel)}");
}
}
else
{
channel = cpipe.Channel;
}
if (channel == null && throwIfChannelIsNull)
{
throw new ArgumentNullException($"The pipe channel is null -> {direction}");
}
return(channel);
}
/// <summary>
/// The default constructor.
/// </summary>
/// <param name="id">The channel Id.</param>
/// <param name="direction">The direction of the channel - Incoming or outgoing</param>
/// <param name="description">The optional description</param>
/// <param name="bLoggerActive">This is the boundary logger active status for the channel.</param>
/// <param name="internalOnly">This property specifies that the channel should only be used for internal messaging.</param>
/// <param name="rewriteRules">A selection of rewrite rules for the channel.</param>
/// <param name="isAutocreated">A boolean property that specifies whether the channel was created automatically by the communications container.</param>
public Channel(string id
, ChannelDirection direction
, string description = null
, bool?bLoggerActive = null
, bool internalOnly = false
, IEnumerable <MessageRedirectRule> rewriteRules = null
, bool isAutocreated = false)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException("id cannot be null or empty.");
}
Id = id;
Direction = direction;
Description = description;
InternalOnly = internalOnly;
BoundaryLoggingActive = bLoggerActive;
IsAutoCreated = isAutocreated;
if (rewriteRules != null)
{
mRedirectRules = new ConcurrentDictionary <Guid, MessageRedirectRule>(
rewriteRules.Select((r) => new KeyValuePair <Guid, MessageRedirectRule>(r.Id, r)));
}
}
public Csound6ChannelEventArgs(string _name, ChannelType _type, ChannelDirection _direction, IntPtr pObject)
{
Name = _name;
Type = _type;
Direction = _direction;
m_pObject = pObject;
}
/// <summary>
///
/// </summary>
/// <param name="csound"></param>
/// <param name="name"></param>
/// <param name="pValue"></param>
/// <param name="pChannelType"></param>
private void RawOutputChannelEventCallback(IntPtr csound, string name, IntPtr pValue, IntPtr pChannelType)
{
var cstype = (CS_TYPE)Marshal.PtrToStructure(pChannelType, typeof(CS_TYPE));
Csound6ChannelEventArgs args = null;
ChannelDirection dir = (ChannelDirection)((cstype.argtype != 0) ? cstype.argtype : 3);
switch (cstype.varTypeName[0])
{
case 'k':
args = new Csound6ChannelEventArgs(name, ChannelType.Control, dir);
args.Value = (double)Marshal.PtrToStructure(pValue, typeof(double));
break;
case 'S':
args = new Csound6ChannelEventArgs(name, ChannelType.String, dir);
args.Value = Marshal.PtrToStringAnsi(pValue);
break;
case 'a': //audio ksmps buffer: not supported by csound output callbacks
case 'p': //pvs: not supported by csound output callbacks
case 'v': //var??? no csound code supports this yet
default:
//only S and k should be sending output channel callbacks. Ignore: someday csound might be supporting some of these
break;
}
Csound6ChannelEventHandler handler = m_callbackHandlers[_outputChannelEventKey] as Csound6ChannelEventHandler;
if ((args != null) && (handler != null))
{
handler(this, args);
}
}
public NidaQmxChannel(NidaQmxDevice2 device, string channel, ChannelDirection direction, IIDGenerator idgen)
{
_status = DevicePortStatus.Idle;
Id = idgen.GetID();
Channel = channel;
Device = device;
_direction = direction;
}
/// <summary>
/// This method checks whether a channel has been adeed.
/// </summary>
/// <param name="channelId">The channel Id.</param>
/// <param name="direction">The direction.</param>
/// <returns></returns>
public bool Exists(string channelId, ChannelDirection direction)
{
var success = Wrapper(direction,
(r) => mContainerIncoming.ContainsKey(channelId) ? true : default(bool?)
, (r) => mContainerOutgoing.ContainsKey(channelId) ? true : r
);
return(success ?? false);
}
public static ChannelDirection GetChannelDirection(string direction)
{
ChannelDirection direct = ChannelDirection.CHANNEL_DIRECTION_UNKOWN;
if (DictDirection.ContainsKey(direction))
{
direct = DictDirection[direction];
}
return(direct);
}
/// <summary>
/// Adds an audio channel object to the bus but doesn't define it to csound
/// </summary>
/// <param name="name"></param>
/// <param name="direction"></param>
public Csound6AudioChannel AddAudioChannel(string name, ChannelDirection direction)
{
if (HasChannel(name) && (m_channels[name].Type != ChannelType.Audio))
{
RemoveChannel(name);
}
m_channels.Add(name, new Csound6AudioChannel(name, direction, m_csound));
m_channels[name].Direction = direction;
return(m_channels[name] as Csound6AudioChannel);
}
public LocalChannel(DirectoryInfo workingDirectory, ChannelSettings channelSettings)
{
_channelSettings = channelSettings ?? throw new ArgumentNullException(nameof(channelSettings));
_workingDirectory = workingDirectory ?? throw new ArgumentNullException(nameof(channelSettings));
_channelDirection = ChannelDirectionFactory.Get(channelSettings);
_source = ChannelHelper.GetSourceOrTarget(_channelSettings, workingDirectory).Item1;
_target = ChannelHelper.GetSourceOrTarget(_channelSettings, workingDirectory).Item2;
}
public ChannelEventArgs(
ChannelEvent @event,
ChannelDirection direction,
string uuid,
string from,
string to)
{
Event = @event;
Direction = direction;
UUID = uuid;
From = from;
To = to;
}
/// <summary>
/// The default constructor.
/// </summary>
/// <param name="id">The channel Id.</param>
/// <param name="direction">The direction of the channel - Incoming or outgoing</param>
/// <param name="description">The optional description</param>
/// <param name="internalOnly">This property specifies that the channel should only be used for internal messaging.</param>
public Channel(string id, ChannelDirection direction, string description = null, IBoundaryLogger boundaryLogger = null, bool internalOnly = false)
{
if (string.IsNullOrEmpty(id))
{
throw new ArgumentNullException("id cannot be null or empty.");
}
Id = id;
Direction = direction;
Description = description;
InternalOnly = internalOnly;
BoundaryLogger = boundaryLogger;
}
public SftpChannel(DirectoryInfo workingDirectory, ChannelSettings channelSettings)
{
_channelSettings = channelSettings ?? throw new ArgumentNullException(nameof(channelSettings));
_workingDirectory = workingDirectory ?? throw new ArgumentNullException(nameof(channelSettings));
_channelDirection = ChannelDirectionFactory.Get(channelSettings);
_source = string.IsNullOrEmpty(channelSettings.Path) ? throw new ArgumentException(nameof(channelSettings.Path)) : channelSettings.Path;
_target = _workingDirectory;
_connectionInfo = channelSettings.AsConnectionInfo();
}
/// <summary>
/// This method is used to ensure either of both collections are invoked for channel based methods.
/// </summary>
/// <param name="direction">The channel direction.</param>
/// <param name="incoming">The incoming function.</param>
/// <param name="outgoing">The outgoing funtion.</param>
/// <returns></returns>
private bool?Wrapper(ChannelDirection direction, Func <bool?, bool?> incoming, Func <bool?, bool?> outgoing)
{
bool?result = null;
if ((direction & ChannelDirection.Incoming) > 0)
{
result = incoming?.Invoke(result);
}
if ((direction & ChannelDirection.Outgoing) > 0)
{
result = outgoing?.Invoke(result);
}
return(result);
}
/// <summary>
/// This interface is used to log payload data when a message is either incoming or outgoing from the system.
/// </summary>
/// <param name="collector">The data collector.</param>
/// <param name="direction">The direction of the message.</param>
/// <param name="payload">The payload.</param>
/// <param name="ex">Any exception generated by the attempt. If this is not null then you can assume that the incoming or outgoing action was not successful.</param>
/// <param name="batchId">The batch id.</param>
public static void BoundaryLog(this IDataCollection collector, ChannelDirection direction
, TransmissionPayload payload, string channelId, int channelPriority, Exception ex = null, Guid?batchId = null)
{
collector.Write(
new BoundaryEvent()
{
Direction = direction
, ChannelId = payload?.Message?.ChannelId
, Id = payload?.Id
, Payload = payload
, Ex = ex
, BatchId = batchId
, Type = BoundaryEventType.Boundary
, ChannelPriority = channelPriority
});
}
private void TestChannelAutocreateFail(ChannelDirection direction)
{
CommunicationContainer mContainer
= new CommunicationContainer(new CommunicationPolicy()
{
AutoCreateChannels = false
});
Channel channel = null;
Assert.IsFalse(mContainer.TryGet("Freddy", direction, out channel));
Assert.IsTrue(channel == null);
Assert.IsFalse(mContainer.Exists("Freddy", direction));
Assert.IsTrue(mContainer.Channels.Count() == 0);
}
private void TestChannelAutocreateSuccess(ChannelDirection direction)
{
CommunicationContainer mContainer
= new CommunicationContainer(new CommunicationPolicy()
{
AutoCreateChannels = true
});
Channel channel;
Assert.IsTrue(mContainer.TryGet("Freddy", direction, out channel));
Assert.IsTrue(mContainer.Exists("Freddy", direction));
Assert.IsTrue(channel.IsAutoCreated);
Assert.IsTrue(mContainer.Channels.Count() == 1);
}
public ChannelInternalOnlyException(string channelId, ChannelDirection direction) : base(channelId)
{
Direction = direction;
}
public bool Parse(string name, string value)
{
switch (name)
{
case "username":
UserName = value;
break;
case "dialplan":
DialplanType = value;
break;
case "caller-id-name":
_callerIdName = value;
CreateCallerId();
break;
case "caller-id-number":
_callerIdNumber = value;
CreateCallerId();
break;
case "callee-id-name":
_calleeIdName = value;
CreateCalleeId();
break;
case "callee-id-number":
_calleeIdNumber = value;
CreateCalleeId();
break;
case "network-addr":
IpAddress = value;
break;
case "ani":
ANI = value;
break;
case "destination-number":
DestinationNumber = value;
break;
case "unique-id":
Id = new UniqueId(value);
break;
case "context":
Context = value;
break;
case "channel-name":
ChannelInfo = new ChannelName();
ChannelInfo.Parse(value);
break;
case "profile-created-time":
ProfileCreatedAt = value.FromUnixTime();
break;
case "channel-created-time":
CreatedAt = value.FromUnixTime();
break;
case "channel-answered-time":
AnsweredAt = value.FromUnixTime();
break;
case "channel-hangup-time":
HangupAt = value.FromUnixTime();
break;
case "channel-transfer-time":
TransferredAt = value.FromUnixTime();
break;
case "screen-bit":
ScreenBit = value == "yes";
break;
case "privacy-hide-name":
PrivacyHideName = value == "yes";
break;
case "privacy-hide-number":
PrivacyHideNumber = value == "yes";
break;
case "direction":
Direction = Enumm.Parse <ChannelDirection>(value);
break;
case "source":
EndpointSource = value;
break;
case "profile-index":
ProfileIndex = int.Parse(value);
break;
case "channel-progress-time":
ChannelProgressTime = long.Parse(value);
break;
case "channel-progress-media-time":
ChannelProgressMediaTime = long.Parse(value);
break;
default:
return(false);
}
return(true);
}
public ChannelIdMismatchException(string channelId, ChannelDirection direction, string mismatchId) : base(channelId)
{
MismatchChannelId = mismatchId;
Direction = direction;
}
public ChannelInfo(string _name, ChannelType _type, ChannelDirection _direction)
{
Name = _name;
Type = _type;
Direction = _direction;
}
public bool Parse(string name, string value)
{
switch (name)
{
case "username":
UserName = value;
break;
case "dialplan":
DialplanType = value;
break;
case "caller-id-name":
_callerIdName = value;
CreateCallerId();
break;
case "caller-id-number":
_callerIdNumber = value;
CreateCallerId();
break;
case "callee-id-name":
_calleeIdName = value;
CreateCalleeId();
break;
case "callee-id-number":
_calleeIdNumber = value;
CreateCalleeId();
break;
case "network-addr":
IpAddress = value;
break;
case "ani":
ANI = value;
break;
case "destination-number":
DestinationNumber = value;
break;
case "unique-id":
Id = new UniqueId(value);
break;
case "context":
Context = value;
break;
case "channel-name":
ChannelInfo = new ChannelName();
ChannelInfo.Parse(value);
break;
case "profile-created-time":
ProfileCreatedAt = value.FromUnixTime();
break;
case "channel-created-time":
CreatedAt = value.FromUnixTime();
break;
case "channel-answered-time":
AnsweredAt = value.FromUnixTime();
break;
case "channel-hangup-time":
HangupAt = value.FromUnixTime();
break;
case "channel-transfer-time":
TransferredAt = value.FromUnixTime();
break;
case "screen-bit":
ScreenBit = value == "yes";
break;
case "privacy-hide-name":
PrivacyHideName = value == "yes";
break;
case "privacy-hide-number":
PrivacyHideNumber = value == "yes";
break;
case "direction":
Direction = Enumm.Parse<ChannelDirection>(value);
break;
case "source":
EndpointSource = value;
break;
case "profile-index":
ProfileIndex = int.Parse(value);
break;
case "channel-progress-time":
ChannelProgressTime = long.Parse(value);
break;
case "channel-progress-media-time":
ChannelProgressMediaTime = long.Parse(value);
break;
default:
return false;
}
return true;
}
/// <summary>
/// Creates a control channel object using the provided name, direction, channel hints and csound instance
/// </summary>
/// <param name="name"></param>
/// <param name="direction"></param>
/// <param name="hints"></param>
/// <param name="csound"></param>
public Csound6ControlChannel(string name, ChannelDirection direction, ChannelHints hints, Csound6Net csound)
: base(name, direction, csound)
{
m_hint = hints;
SetControlChannelHints(hints);
}
public Csound6AudioChannel(string name, ChannelDirection direction, Csound6Net csound)
: base(name, direction, csound)
{
m_bufsiz = csound.Ksmps;
m_buffer = Marshal.AllocHGlobal(sizeof(double) * m_bufsiz);
}
/// <summary>
/// Creates a string channel object to represent a string value in csound shared with a host program
/// </summary>
/// <param name="name"></param>
/// <param name="direction"></param>
/// <param name="csound"></param>
public Csound6StringChannel(string name, ChannelDirection direction, Csound6Net csound)
: base(name, direction, csound)
{
}
/// <summary>
/// Populates abstract superclass values supplied as from concrete channel subclasses.
/// </summary>
/// <param name="_name">Name the channel is known by to csound</param>
/// <param name="_direction">one or both members (Ored to gether) of the ChannelDirection enumeration</param>
/// <param name="csound">A reference to the Csound6NetRealtime used that contains this channel</param>
public Csound6Channel(string _name, ChannelDirection _direction, Csound6Net csound)
{
m_csound = csound;
Name = _name;
Direction = _direction;
}
public void Log(ChannelDirection direction, TransmissionPayload payload, Exception ex = null, Guid?batchId = default(Guid?))
{
}
public EmptyDevicePort(ChannelDirection direction)
{
Direction = direction;
}
/// <summary>
/// This method returns true if the channel is registered for that specific direction.
/// </summary>
/// <param name="channelId">The channel id.</param>
/// <param name="direction">The channel direction.</param>
/// <returns>Returns true if the channel exists.</returns>
public bool HasChannel(string channelId, ChannelDirection direction)
{
return(mCommunication.Exists(channelId, direction));
}
