private async Task <string> WriteTask(string socketKey, byte[] data)
        {
            ISocketAdapter socket = socketStorage.Get(socketKey);
            PluginResult   result = new PluginResult();

            await Task.Run(async() =>
            {
                try
                {
                    await socket.Write(data);
                    result.Result = PluginResult.Status.OK;
                }
                catch (Exception ex)
                {
                    result.Result  = PluginResult.Status.IO_EXCEPTION;
                    result.Message = ex.Message;
                }
            });

            JsonObject jsonObject = new JsonObject();

            jsonObject.SetNamedValue("Result", JsonValue.CreateNumberValue((int)result.Result));
            if (result.Message != null)
            {
                jsonObject.SetNamedValue("Message", JsonValue.CreateStringValue(result.Message));
            }

            return(jsonObject.ToString());
        }
Example #2
0
        /// <summary>
        /// A new socket with server connection and adapter options.
        /// </summary>
        /// <param name="scheme">The protocol scheme. Must be "ws" or "wss".</param>
        /// <param name="host">The host address of the server.</param>
        /// <param name="port">The port number of the server.</param>
        /// <param name="adapter">The adapter for use with the socket.</param>
        public Socket(string scheme, string host, int port, ISocketAdapter adapter)
        {
            Logger     = NullLogger.Instance;
            _adapter   = adapter;
            _baseUri   = new UriBuilder(scheme, host, port).Uri;
            _responses = new ConcurrentDictionary <string, TaskCompletionSource <WebSocketMessageEnvelope> >();

            _adapter.Connected += () => Connected?.Invoke();
            _adapter.Closed    += () =>
            {
                foreach (var response in _responses)
                {
                    response.Value.TrySetCanceled();
                }

                _responses.Clear();
                Closed?.Invoke();
            };
            _adapter.ReceivedError += e =>
            {
                if (!_adapter.IsConnected)
                {
                    foreach (var response in _responses)
                    {
                        response.Value.TrySetCanceled();
                    }

                    _responses.Clear();
                }

                ReceivedError?.Invoke(e);
            };
            _adapter.Received += ReceivedMessage;
        }
 public void Add(string socketKey, ISocketAdapter socketAdapter)
 {
     lock (syncRoot)
     {
         System.Diagnostics.Debug.WriteLine("Add: " + DateTime.Now.Ticks);
         this.socketAdapters.Add(socketKey, socketAdapter);
     }
 }
Example #4
0
        protected MqttProtocolBase(ILogger logger, ISocketAdapter socket)
        {
            Logger = logger;
            Socket = socket;
            Socket.OnMessageReceived(SocketMessageReceived);

            _messageStore.MessageTimeout += MessageStoreOnMessageTimeout;
        }
        public void close(string parameters)
        {
            string socketKey = parameters;

            ISocketAdapter socket = socketStorage.Get(socketKey);

            socket.Close();
        }
        public void shutdownWrite(string parameters)
        {
            string socketKey = parameters;

            ISocketAdapter socket = socketStorage.Get(socketKey);

            socket.ShutdownWrite();
        }
        protected MqttProtocolBase(ILogger logger, ISocketAdapter socket)
        {
            Logger = logger;
            Socket = socket;
            Socket.OnMessageReceived(SocketMessageReceived);

            _messageStore.MessageTimeout += MessageStoreOnMessageTimeout;
        }
Example #8
0
        public void shutdownWrite(string parameters)
        {
            string socketKey = JsonHelper.Deserialize <string[]>(parameters)[0];

            ISocketAdapter socket = this.socketStorage.Get(socketKey);

            socket.ShutdownWrite();
        }
Example #9
0
 public void Add(string socketKey, ISocketAdapter socketAdapter)
 {
     lock (syncRoot)
     {
         System.Diagnostics.Debug.WriteLine("Add: " + DateTime.Now.Ticks);
         this.socketAdapters.Add(socketKey, socketAdapter);
     }
 }
 private static Volt GetVolt(ISocketAdapter socketAdapter, int v)
 {
     return(v switch
     {
         3 => socketAdapter.Get3Volt(),
         12 => socketAdapter.Get12Volt(),
         120 => socketAdapter.Get120Volt(),
         _ => socketAdapter.Get120Volt(),
     });
Example #11
0
        /// <summary>
        /// Build a socket from a client object and socket adapter.
        /// </summary>
        /// <param name="client">A client object.</param>
        /// <param name="adapter">The socket adapter to use with the connection.</param>
        /// <returns>A new socket with connection settings from the client.</returns>
        public static ISocket From(IClient client, ISocketAdapter adapter)
        {
            var scheme = client.Scheme.ToLower().Equals("http") ? "ws" : "wss";

            // TODO improve how logger is passed into socket object.
            return(new Socket(scheme, client.Host, client.Port, adapter)
            {
                Logger = (client as Client)?.Logger
            });
        }
Example #12
0
 internal MqttClient(ISocketAdapter socket, ILogger logger, SocketEncryption encryptionLevel)
 {
     _logger                    = logger;
     _encryptionLevel           = encryptionLevel;
     _mqtt                      = new MqttClientProtocol(_logger, socket);
     _mqtt.ConnectComplete     += MqttOnConnectComplete;
     _mqtt.SubscribeComplete   += MqttOnSubscribeComplete;
     _mqtt.SendMessageComplete += MqttOnOperationComplete;
     _mqtt.NetworkError        += MqttOnNetworkError;
     _mqtt.PublishReceived     += MqttOnPublishReceived;
 }
Example #13
0
        private static Volt getVolt(ISocketAdapter sockAdapter, int i)
        {
            switch (i)
            {
            case 3: return(sockAdapter.get3Volt());

            case 12: return(sockAdapter.get12Volt());

            default: return(sockAdapter.get120Volt());
            }
        }
Example #14
0
 internal MqttClient(ISocketAdapter socket, ILogger logger, SocketEncryption encryptionLevel)
 {
     _logger = logger;
     _encryptionLevel = encryptionLevel;
     _mqtt = new MqttClientProtocol(_logger, socket);
     _mqtt.ConnectComplete += MqttOnConnectComplete;
     _mqtt.SubscribeComplete += MqttOnSubscribeComplete;
     _mqtt.SendMessageComplete += MqttOnSendMessageComplete;
     _mqtt.PublishReceived += MqttOnPublishReceived;
     _mqtt.NetworkError += MqttOnNetworkError;
 }
Example #15
0
        public static async Task <IHttpSocketAdapter> OpenHttpSocketAsync(string httpMethod, Uri url)
        {
            ISocketAdapter socket = await SocketAdapter.OpenSocketAsync(url);

            if (socket != null)
            {
                return(new HttpSocketAdapter(httpMethod, url, socket));
            }

            return(null);
        }
Example #16
0
        public HttpSocketAdapter(string httpMethod, Uri url, ISocketAdapter socket)
        {
            _socket = socket;

            string requestUri = url.GetComponents(UriComponents.PathAndQuery | UriComponents.Fragment, UriFormat.UriEscaped);

            _headerSection.AppendFormat("{0} {1} HTTP/1.1\r\n", httpMethod, requestUri);

            AddRequestHeader("Host", url.GetComponents(UriComponents.HostAndPort, UriFormat.UriEscaped));
            AddRequestHeader("Transfer-Encoding", "chunked");
            AddRequestHeader("Connection", "keep-alive");
        }
Example #17
0
        public void Dispose()
        {
            if (_responseReader != null)
            {
                _responseReader.Stop();
                _responseReader.Dispose();
                _responseReader = null;
            }

            if (_socket != null)
            {
                _socket.Dispose();
                _socket = null;
            }
        }
Example #18
0
        /// <summary>
        /// Private function to get volt
        /// </summary>
        /// <param name="socketAdapter">socketAdapter as a parameter</param>
        /// <param name="v">v as a parameter</param>
        /// <returns>returns volt as per user input</returns>
        private Volt GetVolt(ISocketAdapter socketAdapter, int v)
        {
            switch (v)
            {
            case 3:
                return(socketAdapter.Get3Volt());

            case 12:
                return(socketAdapter.Get12Volt());

            case 120:
                return(socketAdapter.Get120Volt());

            default:
                return(socketAdapter.Get120Volt());
            }
        }
Example #19
0
        /// <summary>
        /// A new socket with server connection and adapter options.
        /// </summary>
        /// <param name="scheme">The protocol scheme. Must be "ws" or "wss".</param>
        /// <param name="host">The host address of the server.</param>
        /// <param name="port">The port number of the server.</param>
        /// <param name="adapter">The adapter for use with the socket.</param>
        /// <param name="sendTimeoutSec">The maximum time allowed for a message to be sent.</param>
        public Socket(string scheme, string host, int port, ISocketAdapter adapter, int sendTimeoutSec = DefaultSendTimeout)
        {
            Logger          = NullLogger.Instance;
            _adapter        = adapter;
            _baseUri        = new UriBuilder(scheme, host, port).Uri;
            _responses      = new Dictionary <string, TaskCompletionSource <WebSocketMessageEnvelope> >();
            _sendTimeoutSec = TimeSpan.FromSeconds(sendTimeoutSec);

            _adapter.Connected += () => Connected?.Invoke();
            _adapter.Closed    += () =>
            {
                lock (_responsesLock)
                {
                    foreach (var response in _responses)
                    {
                        response.Value.TrySetCanceled();
                    }

                    _responses.Clear();
                }

                Closed?.Invoke();
            };
            _adapter.ReceivedError += e =>
            {
                if (!_adapter.IsConnected)
                {
                    lock (_responsesLock)
                    {
                        foreach (var response in _responses)
                        {
                            response.Value.TrySetCanceled();
                        }

                        _responses.Clear();
                    }
                }

                ReceivedError?.Invoke(e);
            };

            _adapter.Received += ProcessMessage;
        }
Example #20
0
        public void write(string parameters)
        {
            string socketKey     = JsonHelper.Deserialize <string[]>(parameters)[0];
            string dataJsonArray = JsonHelper.Deserialize <string[]>(parameters)[1];

            byte[] data = JsonHelper.Deserialize <byte[]>(dataJsonArray);

            ISocketAdapter socket = this.socketStorage.Get(socketKey);

            try
            {
                socket.Write(data).Wait();

                this.DispatchCommandResult(new PluginResult(PluginResult.Status.OK));
            }
            catch (SocketException ex)
            {
                this.DispatchCommandResult(new PluginResult(PluginResult.Status.IO_EXCEPTION, ex.Message));
            }
        }
        public void Listen()
        {
            try
            {
                //вытаскиваем параметры подключения к астериску
                var asteriskConfiguration = mPbxConfigurationService.GetPbxConfiguration();
                var loginCommand          = mPbxConfigurationService.GetLoginCommand(asteriskConfiguration);

                using (ISocketAdapter socket = mSocketAdapterFactory.CreateSocketAdapter())
                {
                    //Создаём сокет для подключения к астериску и подключаемся к нему
                    socket.Connect(asteriskConfiguration.IpAddress, asteriskConfiguration.Port);

                    //авторизуемся
                    socket.Send(Encoding.ASCII.GetBytes(loginCommand));

                    //читаем cSocketReadBufer байт из сокета
                    var bytesRead = 1;

                    while (bytesRead != 0)
                    {
                        var asteriskAnswer = new byte[cSocketReadBufer];
                        bytesRead = socket.Receive(asteriskAnswer);

                        OnFullMessageRecived(new PbxRawMessageEventArgs {
                            Message = Encoding.ASCII.GetString(asteriskAnswer, 0, asteriskAnswer.Length)
                        });
                        //Полученный массив байт преобразуем к строке
                        var asteriskMessage = ParseFullAsteriskMessage(asteriskAnswer);

                        var messages       = mPbxMessagesParser.ExtractPbxMessages(asteriskMessage);
                        var parsedMessages =
                            messages
                            .Select
                            (
                                t => mPbxMessagesParser.ParseMessage(t)
                            )
                            .Where
                            (
                                r =>
                                r.ContainsKey("Event")
                                &&
                                mValueableEvents.Contains(r["Event"])
                            )
                            .ToList();

                        //Если нашли события, запускаем событие полученного сообщения
                        if (parsedMessages.Any())
                        {
                            OnPbxMessageRecived(new PbxMessagesEventArgs {
                                Messages = parsedMessages
                            });
                        }

                        //Читаем следующее сообщение
                        //asteriskAnswer = socket.Receive(cSocketReadBufer);
                    }
                }
            }
            catch (Exception ex)
            {
                var errorMessage = String.Format("Подключение к астериску отвалилось с ошибкой. \r\n {0}", ex);
                OnPbxConnectionLost(new PbxErrorEventArgs {
                    ErrorMessage = errorMessage
                });
            }


            OnPbxConnectionLost(new PbxErrorEventArgs {
                ErrorMessage = "Подключение к астериску отвалилось"
            });
        }
Example #22
0
 public MqttClientProtocol(ILogger logger, ISocketAdapter socket) :
     base(logger, socket)
 {
     _keepAliveTimer = new ThreadSafeTimeoutTimer(MqttProtocolInformation.Settings.KeepAliveTime);
     _keepAliveTimer.Timeout += KeepAliveTimerOnTimeout;
 }
Example #23
0
 /// <summary>
 /// A new socket with an adapter.
 /// </summary>
 /// <param name="adapter">The adapter for use with the socket.</param>
 public Socket(ISocketAdapter adapter) : this(Client.DefaultScheme, Client.DefaultHost, Client.DefaultPort,
                                              adapter)
 {
 }
Example #24
0
 public void Setup()
 {
     _socketAdapter = new SocketAdapter();
 }
Example #25
0
 public MockSocket(ISocketAdapter socketAdapter)
 {
     _socketAdapter = socketAdapter;
 }
Example #26
0
 internal SocketReader(ISocketAdapter socket)
 {
     _socket = socket;
 }
Example #27
0
            public ResponseReader(ISocketAdapter socket)
            {
                _socketReader = new SocketReader(socket);

                _responseCompleteTask = ReadResponse();
            }
Example #28
0
 public HomeController(ISocketAdapter socketAdapter, IMockSocket mockSocket)
 {
     _socketAdapter = socketAdapter;
     _mockSocket    = mockSocket;
 }
Example #29
0
 public SimpleController(ILogger <TestController> logger, ISocketAdapter socketAdapter)
 {
     _logger        = logger;
     _socketAdapter = socketAdapter;
 }