private async Task CreateChannelAsync()
{
if (channel != null)
{
channel.Dispose();
channel = null;
}
if (retryCount > 0)
{
if (retryPolicy.ShouldRetry(retryCount++))
{
retryPolicy.Delay();
}
else
{
retryCount = 0;
}
}
else
{
retryCount++;
}
channel = ChannelFactory.Create(false, new IPEndPoint(IPAddress.Parse(slave.IPAddress), slave.Port), 1024, 102400, CancellationToken.None);
channel.OnOpen += Channel_OnOpen;
channel.OnReceive += Channel_OnReceive;
channel.OnError += Channel_OnError;
channel.OnClose += Channel_OnClose;
logger?.LogDebug($"Slave channel '{channel.Id}' with Id = '{slave.UnitId}' created.");
await channel.OpenAsync();
}
static void Main(string[] args)
{
Sequence workflow;
WorkflowServiceHost host = null;
try
{
workflow = CreateWorkflow();
host = new WorkflowServiceHost(workflow, new Uri("net.pipe://localhost"));
ResumeBookmarkEndpoint endpoint = new ResumeBookmarkEndpoint(new NetNamedPipeBinding(NetNamedPipeSecurityMode.None), new EndpointAddress("net.pipe://localhost/workflowCreationEndpoint"));
host.AddServiceEndpoint(endpoint);
host.Open();
IWorkflowCreation client = new ChannelFactory <IWorkflowCreation>(endpoint.Binding, endpoint.Address).CreateChannel();
//create an instance
Guid id = client.Create(null);
Console.WriteLine("Workflow instance {0} created", id);
//resume bookmark
client.ResumeBookmark(id, "hello", "Hello World!");
Console.WriteLine("Press return to exit ...");
Console.ReadLine();
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
finally
{
if (host != null)
{
host.Close();
}
}
}
public void LoadJumpChannel(string fileName)
{
JumpChannelHandle = ChannelFactory.Create(fileName, BASSFlag.BASS_MUSIC_LOOP);
if (!JumpChannelHandle.Valid)
{
throw new Exception("Failed to load the jump channel.");
}
Bass.BASS_ChannelSetAttribute(JumpChannelHandle.Handle, BASSAttribute.BASS_ATTRIB_VOL, 0f);
JumpChannelSyncs.Add(
new Sync(
JumpChannelHandle,
BASSSync.BASS_SYNC_SLIDE | BASSSync.BASS_SYNC_MIXTIME,
(handle, channel, data, user) =>
{
var volume = 0.0f;
Bass.BASS_ChannelGetAttribute(JumpChannelHandle.Handle, BASSAttribute.BASS_ATTRIB_VOL, ref volume);
if (volume >= MaximumVolume * 0.45f)
{
Console.WriteLine("Will fade next frame.");
_fadeJumpNextFrame = true;
}
}
)
);
}
public List <AuditLogEntryDTO> Handle(GetAuditEntriesQuery queryOptions)
{
var token = _httpContextAccessor.HttpContext.GetTokenAsync(OpenIdConnectParameterNames.AccessToken).GetAwaiter().GetResult();
var headers = new Metadata
{
{ "Authorization", $"Bearer {token}" },
};
var client = new AuditLogClient(ChannelFactory.Create(_configuration["Services:AuditLog:Grpc"]));
var entries = client.GetAuditLogEntries(new GetAuditLogEntriesRequest
{
ObjectId = queryOptions.ObjectId,
}, headers);
return(entries.Entries.Select(x => new AuditLogEntryDTO
{
Id = Guid.Parse(x.Id),
ObjectId = x.ObjectId,
UserId = Guid.Parse(x.UserId),
Action = x.Action,
Log = x.Log,
UserName = x.UserName,
CreatedDateTime = x.CreatedDateTime.ToDateTimeOffset(),
}).ToList());
}
public void LoadStartFlightChannel(string fileName)
{
StartFlightChannelHandle = ChannelFactory.Create(fileName);
if (!StartFlightChannelHandle.Valid)
{
throw new Exception("Failed to load start boost channel.");
}
Bass.BASS_ChannelSetAttribute(StartFlightChannelHandle.Handle, BASSAttribute.BASS_ATTRIB_VOL, 0f);
StartFlightChannelSyncs.Add(
new Sync(
StartFlightChannelHandle,
BASSSync.BASS_SYNC_END,
(handle, channel, data, user) =>
{
if (FlightChannelHandle != null)
{
var volume = 0.0f;
Bass.BASS_ChannelGetAttribute(StartFlightChannelHandle.Handle, BASSAttribute.BASS_ATTRIB_VOL, ref volume);
if (volume > 0.0f)
{
Bass.BASS_ChannelSetAttribute(FlightChannelHandle.Handle, BASSAttribute.BASS_ATTRIB_VOL, MaximumVolume);
}
Bass.BASS_ChannelPlay(FlightChannelHandle.Handle, true);
}
}
)
);
}
private void OnAcceptSocket(IAsyncResult ar)
{
try {
var socket = _listener.EndAcceptSocket(ar);
socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, 1);
socket.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Linger, new LingerOption(true, 1));
var decoder = _configuration.DecoderFactory();
var encoder = _configuration.EncoderFactory();
var channel = ChannelFactory.Create(_bufferPool.Pop(), encoder, decoder);
channel.Disconnected += OnChannelDisconnect;
channel.MessageReceived += OnMessage;
channel.Assign(socket);
_channels.TryAdd(channel.ChannelId, channel);
var args = OnClientConnected(channel);
if (!args.MayConnect)
{
if (args.Response != null)
{
channel.Send(args.Response);
}
channel.Close();
return;
}
}
catch (Exception exception) {
ListenerError(this, new ErrorEventArgs(exception));
}
if (_listener != null)
{
_listener.BeginAcceptSocket(OnAcceptSocket, null);
}
}
private void EnsureConnected()
{
if (_channel == null || _channel.IsClosed)
{
_channel = _channelFactory.Create(automaticRecoveryEnabled: false, requestedHeartbeat: 60);
}
}
public async Task RunAsync()
{
listener = new TcpListener(new IPEndPoint(GetIPAddress(System.Net.Dns.GetHostName()), 502));
listener.ExclusiveAddressUse = false;
listener.Start();
while (true)
{
try
{
TcpClient tcpClient = await listener.AcceptTcpClientAsync();
tcpClient.LingerState = new LingerOption(true, 0);
tcpClient.NoDelay = true;
tcpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
CancellationTokenSource cts = new CancellationTokenSource();
IChannel channel = ChannelFactory.Create(false, tcpClient, 1024, 1024 * 100, cts.Token);
RtuMap map = await RtuMap.LoadAsync(config.RtuMapSasUri); //load RTU map so always up to date.
VirtualRtuAdapter adapter = new VirtualRtuAdapter(map, channel);
adapters.Add(adapter.Id, adapter);
sources.Add(adapter.Id, cts);
adapter.OnError += Adapter_OnError;
adapter.OnClose += Adapter_OnClose;
await adapter.StartAsync();
}
catch (Exception ex)
{
OnError?.Invoke(this, new ListenerErrorEventArgs(ex));
}
}
}
private PiraeusMqttClient AddClient()
{
CancellationTokenSource cts = new CancellationTokenSource();
//string uriString = String.Format("wss://{0}/ws/api/connect", hostname);
Uri uri = new Uri(endpoint);
IChannel channel = ChannelFactory.Create(uri, securityToken, "mqtt", new WebSocketConfig(), cts.Token);
//IChannel channel = new WebSocketClientChannel(new Uri(endpoint), "mqtt", new WebSocketConfig(), cts.Token);
//IChannel channel = ChannelFactory.Create(new Uri(endpoint), securityToken, "mqtt", new WebSocketConfig(), cts.Token);
PiraeusMqttClient client = new PiraeusMqttClient(new MqttConfig(90), channel);
try
{
ConnectAckCode code = client.ConnectAsync(Guid.NewGuid().ToString(), "JWT", securityToken, 90).GetAwaiter().GetResult();
if (code != ConnectAckCode.ConnectionAccepted)
{
//Houston, we have a problem
}
else
{
clients.Add(channel.Id, client);
sources.Add(channel.Id, cts);
channels.Add(channel.Id, channel);
}
}
catch (Exception ex)
{
Console.WriteLine($"Connnect pool failed to add client with - {ex.Message}");
}
return(client);
}
protected override void OpenCore()
{
_inStream = new ProducerConsumerStream();
_outStream = new ProducerConsumerStream();
InnerChannels.Add(ChannelFactory.Create(_inStream, _outStream));
}
public void Execute(IStepContext context)
{
if (context == null)
{
throw new ArgumentNullException($"{nameof(context)}");
}
var ctx = context.Parent;
while (ctx.ProcessingStep.GetType().FullName != typeof(ExecutiveOffice.EDT.FileOps.Steps.From.From).FullName)
{
if (ctx.Parent == null)
{
return; // throw new ArgumentOutOfRangeException($"Missing step {nameof(From.From)}");
}
ctx = ctx.Parent;
}
IChannel channel = ChannelFactory.Create(ctx.FromSettings, ctx.WorkingDirectory);
try
{
channel.Delete(ctx.Files);
context.WorkingDirectory.DeleteWithContentIfExists();
}catch (Exception ex)
{
throw new ApplicationException("Exception occured during TearDown Delete", ex);
}
}
public void LoadLoopChannel(string fileName)
{
LoopChannelHandle = ChannelFactory.Create(fileName, BASSFlag.BASS_MUSIC_LOOP);
if (!LoopChannelHandle.Valid)
{
throw new Exception("Failed to load the loop channel.");
}
}
/// <summary>
/// Loads and initializes the channels.
/// </summary>
public static void Channels()
{
var channels = ClientState.Current.DataService.SelectAll <ChannelConfig>();
foreach (var channel in channels)
{
ChannelsManager.Add(ChannelFactory.Create(channel));
}
}
public void Execute(IStepContext context)
{
context.WorkingDirectory.Create();
IChannel channel = ChannelFactory.Create(_settings, context.WorkingDirectory);
var processedFiles = channel.Copy();
context.Attach(processedFiles);
}
public void LoadFlightChannel(string fileName)
{
FlightChannelHandle = ChannelFactory.Create(fileName, BASSFlag.BASS_MUSIC_LOOP);
if (!FlightChannelHandle.Valid)
{
throw new Exception("Failed to load the flight channel.");
}
Bass.BASS_ChannelSetAttribute(FlightChannelHandle.Handle, BASSAttribute.BASS_ATTRIB_VOL, 0f);
}
private static void Main(string[] args)
{
var channelFactory = new ChannelFactory
{
Type = ChannelType.Tcp,
ConnectEndPoint = new IPEndPoint(IPAddress.Loopback, 5001),
CreateChannelLogger = () => null,
CreateObserverRegistry = () => new ObserverRegistry(),
PacketSerializer = PacketSerializer.CreatePacketSerializer()
};
// TCP
var driver = new TestDriver();
driver.Run(channelFactory.Create()).Wait();
// UDP
channelFactory.Type = ChannelType.Udp;
driver.Run(channelFactory.Create()).Wait();
}
protected override void OpenCore()
{
var option = ((IOptions <SerialPortDataTransportOption>)Option);
_serialPort = new System.IO.Ports.SerialPort(option.Value.PortName, option.Value.BaudRate, option.Value.Parity, option.Value.DataBits, option.Value.StopBits)
{
ReadTimeout = option.Value.ReadTimeout
};
_serialPort.Open();
InnerChannels.Add(ChannelFactory.Create(_serialPort.BaseStream));
}
public List <UserDTO> Handle(GetUsersQuery query)
{
var client = new User.UserClient(ChannelFactory.Create(_configuration["Services:Identity:Grpc"]));
var response = client.GetUsersAsync(new GetUsersRequest()).GetAwaiter().GetResult();
return(response.Users.Select(x => new UserDTO
{
Id = Guid.Parse(x.Id),
UserName = x.UserName,
Email = x.Email,
}).ToList());
}
public List <UserDTO> Handle(GetUsersQuery query)
{
var client = new User.UserClient(ChannelFactory.Create("https://localhost:5001"));
var response = client.GetUsersAsync(new GetUsersRequest()).GetAwaiter().GetResult();
return(response.Users.Select(x => new UserDTO
{
Id = Guid.Parse(x.Id),
UserName = x.UserName,
Email = x.Email,
}).ToList());
}
private void CreateChannel(ChannelFactory channelFactory = null)
{
if (Active)
{
_channelFactory = channelFactory ?? new ChannelFactory();
if (Host == null)
{
Host = DefaultHostFinder.FindLocalIp();
}
_channel = _channelFactory.Create(Host, Port, Buffer);
}
}
public RestClient(string endpoint, X509Certificate2 certificate, IEnumerable <Observer> observers = null, CancellationToken token = default(CancellationToken))
{
sendChannel = ChannelFactory.Create(endpoint, certificate) as HttpClientChannel;
if (observers != null)
{
receiveChannel = ChannelFactory.Create(endpoint, certificate, observers, token);
Task receiveTask = receiveChannel.ReceiveAsync();
Task.WhenAll(receiveTask);
}
}
public async Task RunAsync()
{
#if DEBUG
listener = new TcpListener(new IPEndPoint(IPAddress.Parse("127.0.0.1"), 502));
#else
listener = new TcpListener(new IPEndPoint(GetIPAddress(Dns.GetHostName()), 502));
#endif
listener.ExclusiveAddressUse = false;
listener.Start();
logger?.LogInformation("SCADA client listener started.");
while (true)
{
try
{
TcpClient tcpClient = await listener.AcceptTcpClientAsync();
tcpClient.LingerState = new LingerOption(true, 0);
tcpClient.NoDelay = true;
tcpClient.Client.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
CancellationTokenSource cts = new CancellationTokenSource();
logger?.LogDebug("SCADA client connection acquired.");
IChannel inputChannel = ChannelFactory.Create(false, tcpClient, 1024, 1024 * 100, cts.Token);
logger?.LogDebug("SCADA client created TCP input channel");
IChannel outputChannel = new VirtualRtuChannel(config, logger);
logger?.LogDebug("SCADA client created VRTU output channel");
MbapMapper mapper = new MbapMapper(Guid.NewGuid().ToString());
PipelineBuilder builder = new PipelineBuilder(logger);
Pipeline pipeline = builder.AddConfig(config)
.AddInputChannel(inputChannel)
.AddOutputChannel(outputChannel)
.AddInputFilter(new InputMapFilter(mapper))
.AddOutputFilter(new OutputMapFilter(mapper))
.Build();
logger?.LogDebug("SCADA client pipeline built.");
pipeline.OnPipelineError += Pipeline_OnPipelineError;
pipelines.Add(pipeline.Id, pipeline);
pipeline.Execute();
logger?.LogDebug("SCADA client pipeline executed.");
}
catch (Exception ex)
{
logger?.LogError(ex, "Fault creating pipeline.");
}
}
}
public static ProtocolAdapter Create(PiraeusConfig config, GraphManager graphManager,
IAuthenticator authenticator, TcpClient client, ILog logger = null, CancellationToken token = default)
{
TlsPskIdentityManager pskManager = null;
if (!string.IsNullOrEmpty(config.PskStorageType))
{
if (config.PskStorageType.ToLowerInvariant() == "redis")
{
pskManager = TlsPskIdentityManagerFactory.Create(config.PskRedisConnectionString);
}
if (config.PskStorageType.ToLowerInvariant() == "keyvault")
{
pskManager = TlsPskIdentityManagerFactory.Create(config.PskKeyVaultAuthority,
config.PskKeyVaultClientId, config.PskKeyVaultClientSecret);
}
if (config.PskStorageType.ToLowerInvariant() == "environmentvariable")
{
pskManager = TlsPskIdentityManagerFactory.Create(config.PskIdentities, config.PskKeys);
}
}
IChannel channel;
if (pskManager != null)
{
channel = ChannelFactory.Create(config.UsePrefixLength, client, pskManager, config.BlockSize,
config.MaxBufferSize, token);
}
else
{
channel = ChannelFactory.Create(config.UsePrefixLength, client, config.BlockSize, config.MaxBufferSize,
token);
}
IPEndPoint localEP = (IPEndPoint)client.Client.LocalEndPoint;
int port = localEP.Port;
if (port == 5684)
{
return(new CoapProtocolAdapter(config, graphManager, authenticator, channel, logger));
}
if (port == 1883 || port == 8883)
{
return(new MqttProtocolAdapter(config, graphManager, authenticator, channel, logger));
}
throw new ProtocolAdapterPortException("TcpClient port does not map to a supported protocol.");
}
protected override void InitializeTarget()
{
base.InitializeTarget();
if (Active)
{
if (Host == null)
{
Host = DefaultHostFinder.FindLocalIp();
}
_channel = _channelFactory.Create(Host, Port, Buffer);
}
}
public void Handle(AddSmsMessageCommand command)
{
var client = new SmsClient(ChannelFactory.Create(_configuration["Services:Notification:Grpc"]));
client.AddSmsMessage(new Notification.Grpc.AddSmsMessageRequest
{
Message = new Notification.Grpc.SmsMessage
{
Message = command.SmsMessage.Message,
PhoneNumber = command.SmsMessage.PhoneNumber,
},
});
}
protected override void OpenCore()
{
var settings = ((SerialPortDataTransportSettings)Settings);
var serialPortDataTransportsettings = settings;
_serialPort = new System.IO.Ports.SerialPort(serialPortDataTransportsettings.PortName, serialPortDataTransportsettings.BaudRate, serialPortDataTransportsettings.Parity, serialPortDataTransportsettings.DataBits, serialPortDataTransportsettings.StopBits)
{
ReadTimeout = serialPortDataTransportsettings.ReadTimeout
};
_serialPort.Open();
InnerChannels.Add(ChannelFactory.Create(_serialPort.BaseStream));
}
public void Handle(AddSmsMessageCommand command)
{
var client = new SmsClient(ChannelFactory.Create("https://localhost:5003"));
client.AddSmsMessage(new Notification.Grpc.AddSmsMessageRequest
{
Message = new Notification.Grpc.SmsMessage
{
Message = command.SmsMessage.Message,
PhoneNumber = command.SmsMessage.PhoneNumber,
},
});
}
public async Task OpenAsync()
{
cts = new CancellationTokenSource();
channel = ChannelFactory.Create(false, new IPEndPoint(IPAddress.Parse(address), port), 1024, 102400,
cts.Token);
channel.OnClose += Channel_OnClose;
channel.OnError += Channel_OnError;
channel.OnReceive += Channel_OnReceive;
channel.OnOpen += Channel_OnOpen;
channel.OnStateChange += Channel_OnStateChange;
await channel.OpenAsync();
}
public void LoadStartJumpChannel(string fileName)
{
StartJumpChannelHandle = ChannelFactory.Create(fileName);
if (!StartJumpChannelHandle.Valid)
{
throw new Exception("Failed to load start boost channel.");
}
Bass.BASS_ChannelSetAttribute(StartJumpChannelHandle.Handle, BASSAttribute.BASS_ATTRIB_VOL, 0f);
StartJumpChannelSyncs.Add(
new Sync(
StartJumpChannelHandle,
BASSSync.BASS_SYNC_END,
(handle, channel, data, user) =>
{
if (JumpChannelHandle != null)
{
var volume = 0.0f;
Bass.BASS_ChannelGetAttribute(StartJumpChannelHandle.Handle, BASSAttribute.BASS_ATTRIB_VOL, ref volume);
if (volume > 0.0f)
{
Bass.BASS_ChannelSetAttribute(JumpChannelHandle.Handle, BASSAttribute.BASS_ATTRIB_VOL, MaximumVolume);
}
Bass.BASS_ChannelPlay(JumpChannelHandle.Handle, true);
}
}
)
);
StartJumpChannelSyncs.Add(
new Sync(
StartJumpChannelHandle,
BASSSync.BASS_SYNC_SLIDE | BASSSync.BASS_SYNC_MIXTIME,
(handle, channel, data, user) =>
{
var volume = 0.0f;
Bass.BASS_ChannelGetAttribute(StartJumpChannelHandle.Handle, BASSAttribute.BASS_ATTRIB_VOL, ref volume);
if (volume >= MaximumVolume * 0.5f)
{
Console.WriteLine($"Will fade. Volume {volume} hit.");
_fadeJumpNextFrame = true;
}
}
)
);
}
public RestClient(string endpoint, string securityToken, IEnumerable <Observer> observers = null, CancellationToken token = default(CancellationToken))
{
sendChannel = ChannelFactory.Create(endpoint, securityToken) as HttpClientChannel;
if (observers != null)
{
receiveChannel = ChannelFactory.Create(endpoint, securityToken, observers, token);
Task openTask = receiveChannel.OpenAsync();
Task.WaitAll(openTask);
Task receiveTask = receiveChannel.ReceiveAsync();
Task.WhenAll(receiveTask);
}
}
/// <summary>
/// Create protocol adapter for rest service or Web socket
/// </summary>
/// <param name="config"></param>
/// <param name="request"></param>
/// <param name="token"></param>
/// <param name="authenticator"></param>
/// <returns></returns>
public static ProtocolAdapter Create(PiraeusConfig config, HttpContext context, ILogger logger = null, IAuthenticator authenticator = null, CancellationToken token = default(CancellationToken))
{
IChannel channel = null;
//HttpContext context = HttpContext.Current;
//if (context.IsWebSocketRequest ||
// context.IsWebSocketRequestUpgrading)
//if (HttpHelper.HttpContext.WebSockets.IsWebSocketRequest)
if (context.WebSockets.IsWebSocketRequest)
{
//WebSocketConfig webSocketConfig = GetWebSocketConfig(config);
WebSocketConfig webSocketConfig = new WebSocketConfig(config.MaxBufferSize, config.BlockSize, config.BlockSize);
channel = ChannelFactory.Create(context, webSocketConfig, token);
//channel = ChannelFactory.Create(request, webSocketConfig, token);
//if (context.WebSocketRequestedProtocols.Contains("mqtt"))
if (context.WebSockets.WebSocketRequestedProtocols.Contains("mqtt"))
{
return(new MqttProtocolAdapter(config, authenticator, channel, logger));
}
else if (context.WebSockets.WebSocketRequestedProtocols.Contains("coapv1")) //(context.WebSocketRequestedProtocols.Contains("coapv1"))
{
return(new CoapProtocolAdapter(config, authenticator, channel, logger));
}
//else if (context.WebSocketRequestedProtocols.Count == 0)
//{
// //wsn protocol
// //return new WsnProtocolAdapter(config, channel);
//}
else
{
throw new InvalidOperationException("invalid web socket subprotocol");
}
}
//if (request.Method != HttpMethod.Post && request.Method != HttpMethod.Get)
if (context.Request.Method.ToUpperInvariant() != "POST" && context.Request.Method.ToUpperInvariant() != "GET")
{
throw new HttpRequestException("Protocol adapter requires HTTP get or post.");
}
else
{
//channel = ChannelFactory.Create(request);
channel = ChannelFactory.Create(context);
return(new RestProtocolAdapter(config, channel, context, logger));
}
}