Esempio n. 1
0
        private object SendBufferProcess(object o)
        {
            while (true)
            {
                try
                {
                    var bytes = _txQueue.Dequeue();
                    if (bytes == null)
                    {
                        CloudLog.Notice("Exiting {0}", Thread.CurrentThread.Name);
                        return(null);
                    }
#if DEBUG
                    Debug.WriteInfo("Samsung Tx",
                                    Debug.AnsiPurple + Tools.GetBytesAsReadableString(bytes, 0, bytes.Length, false) +
                                    Debug.AnsiReset);
#endif
                    _comPort.Send(bytes, bytes.Length);
                    CrestronEnvironment.AllowOtherAppsToRun();
                    Thread.Sleep(10);
                }
                catch (Exception e)
                {
                    if (e.Message != "ThreadAbortException")
                    {
                        CloudLog.Exception(string.Format("{0} - Exception in tx buffer thread", GetType().Name), e);
                    }
                }
            }
        }
Esempio n. 2
0
        protected virtual void DspOnHasIntitialized(QsysCore core)
        {
            CloudLog.Notice(string.Format("Q-Sys Core: \"{0}\" Has Intitialized!", core.Name));
            foreach (var component in core)
            {
                foreach (var control in component)
                {
                    CloudLog.Info("Core Control: {0}", control.ToString());
                }
            }

            foreach (var itemConfig in ConfigManager.Config.DspFaderComponents.Where(c => !string.IsNullOrEmpty(c.TrafficLightBaseName)))
            {
                try
                {
                    core.GetChangeGroup("TrafficLights").Add(core[itemConfig.TrafficLightBaseName + ".signal"]);
                    core.GetChangeGroup("TrafficLights").Add(core[itemConfig.TrafficLightBaseName + ".good"]);
                    core.GetChangeGroup("TrafficLights").Add(core[itemConfig.TrafficLightBaseName + ".peak"]);
                }
                catch
                {
                }
            }

            core.GetChangeGroup("TrafficLights").PollAuto(0.2);
        }
Esempio n. 3
0
        public void Start()
        {
            if (_started)
            {
                throw new InvalidOperationException("Already started");
            }

            _started = true;
            var v = _ioPort as Versiport;

            if (v != null)
            {
                _normalState = v.DigitalIn;
            }
            else
            {
                var d = _ioPort as DigitalInput;
                if (d != null)
                {
                    _normalState = d.State;
                }
            }

            CloudLog.Notice("Fire interface normal state set initialized at {0}",
                            _normalState ? "Closed" : "Open");

            _socket.Start();
        }
Esempio n. 4
0
        protected virtual void OnDeviceCommunicatingChange(IDevice device, bool communicating)
        {
            var handler = DeviceCommunicatingChange;

            if (handler == null)
            {
                return;
            }
            try
            {
                if (communicating)
                {
                    CloudLog.Notice("{0}.DeviceCommunicating = {1}", GetType().Name, true);
                }
                else
                {
                    CloudLog.Warn("{0}.DeviceCommunicating = {1}", GetType().Name, false);
                }
                handler(device, communicating);
            }
            catch (Exception e)
            {
                CloudLog.Exception(e);
            }
        }
Esempio n. 5
0
        public void Connect()
        {
            if (_client != null && _client.IsConnected)
            {
                CloudLog.Warn("{0} already connected", GetType().Name);
                return;
            }

            _reconnect = true;

            var info = new KeyboardInteractiveConnectionInfo(_address, _port, _username);

            info.AuthenticationPrompt += OnPasswordPrompt;

            _client = new SshClient(info);
            _client.ErrorOccurred +=
                (sender, args) => CloudLog.Exception(args.Exception, "SshClient.ErrorOccurred Event");
            _client.HostKeyReceived +=
                (sender, args) =>
                CloudLog.Notice("{0} HostKeyReceived: {1}, can trust = {2}", GetType().Name, args.HostKeyName,
                                args.CanTrust);

            _sshProcess = new Thread(SshCommsProcess, null, Thread.eThreadStartOptions.CreateSuspended)
            {
                Name     = "CodecSshClient Comms Handler",
                Priority = Thread.eThreadPriority.MediumPriority
            };

            _sshProcess.Start();
        }
Esempio n. 6
0
        private bool CheckIfNewVersion(Assembly appAssembly)
        {
            try
            {
                var runningVersion = appAssembly.GetName().Version;

                CloudLog.Info("Checking version of {0} to see if \"{1}\" is new", appAssembly.GetName().Name,
                              runningVersion);

                var filePath = string.Format("{0}\\{1}_version.info", AppStoragePath, appAssembly.GetName().Name);

                if (!File.Exists(filePath))
                {
                    using (var newFile = File.OpenWrite(filePath))
                    {
                        newFile.Write(runningVersion.ToString(), Encoding.UTF8);
                    }
                    CloudLog.Notice("Version file created at \"{0}\", app must be updated or new", filePath);
                    return(true);
                }

                bool appIsNewVersion;

                using (var file = new StreamReader(filePath, Encoding.UTF8))
                {
                    var contents = file.ReadToEnd().Trim();
                    var version  = new Version(contents);
                    appIsNewVersion = runningVersion.CompareTo(version) != 0;
                    if (appIsNewVersion)
                    {
                        CloudLog.Warn("APP UPDATED TO {0}", runningVersion.ToString());
                    }
                    else
                    {
                        CloudLog.Notice("App version remains as {0}", runningVersion.ToString());
                    }
                }

                if (appIsNewVersion)
                {
                    File.Delete(filePath);

                    using (var newFile = File.OpenWrite(filePath))
                    {
                        newFile.Write(runningVersion.ToString(), Encoding.UTF8);
                    }
                    CloudLog.Notice("Version file deleted and created at \"{0}\", with new version number", filePath);
                }

                return(appIsNewVersion);
            }
            catch (Exception e)
            {
                CloudLog.Error("Error checking if app is new version, returning true, {0}", e.Message);
                return(true);
            }
        }
Esempio n. 7
0
 public void Stop()
 {
     CloudLog.Notice("Stopping {0} instance on TCP port {1}", GetType().Name, _socket.PortNumber);
     if (_socket != null)
     {
         var message = Encoding.ASCII.GetBytes("Closing connections!\r\n");
         SendToAll(message, 0, message.Length);
         _socket.DisconnectAll();
     }
 }
Esempio n. 8
0
        public void Initialize()
        {
            if (_timer != null && !_timer.Disposed)
            {
                return;
            }

            CloudLog.Notice("{0}.Initialize() for address {1}", GetType().Name, _address);

            _timer = new CTimer(specific => GetStatus(), null, 1000, 60000);
        }
Esempio n. 9
0
        protected override void PowerOff(PowerOfFEventType eventType)
        {
            Source = null;
            foreach (var display in Displays.Where(display => display.Device != null))
            {
#if DEBUG
                CloudLog.Notice("{0} Power Off!", display.Device.Name);
#endif
                display.Device.Power = false;
            }
        }
Esempio n. 10
0
        private object ReceiveHandler(object userSpecific)
        {
            var clientIndex = (uint)userSpecific;

            CloudLog.Notice("{0} rx handler on TCP port {1}, is running for client index {2}", GetType().Name, _socket.PortNumber, clientIndex);

            try
            {
                OnClientConnect(clientIndex);
            }
            catch (Exception e)
            {
                CloudLog.Exception(e);
            }

            while (true)
            {
                try
                {
                    var count = _socket.ReceiveData(clientIndex);

                    if (count <= 0)
                    {
                        CloudLog.Debug("{0} - Client Index {1} Received data count of {2}, Disconnected? - Exiting Thread",
                                       GetType().Name, clientIndex, count);

                        try
                        {
                            OnClientDisconnect(clientIndex);
                        }
                        catch (Exception e)
                        {
                            CloudLog.Exception(e);
                        }

                        return(null);
                    }

                    OnClientReceive(clientIndex, _socket.GetIncomingDataBufferForSpecificClient(clientIndex), count);
                }
                catch (Exception e)
                {
                    CloudLog.Exception(e,
                                       "Error in {0} for client index {1}, closing connection and exiting rx handler thread",
                                       Thread.CurrentThread.Name, clientIndex);
                    if (_connections[clientIndex] == SocketStatus.SOCKET_STATUS_CONNECTED)
                    {
                        _socket.Disconnect(clientIndex);
                        return(null);
                    }
                }
            }
        }
Esempio n. 11
0
 private void AmOnIpInformationChange(GenericBase currentDevice, ConnectedIpEventArgs args)
 {
     if (!args.Connected)
     {
         return;
     }
     CloudLog.Notice("{0} has connected on IP {1}", currentDevice, args.DeviceIpAddress);
     if (currentDevice.ConnectedIpList.Count == 1)
     {
         _deviceIpAddress = currentDevice.ConnectedIpList.First().DeviceIpAddress;
     }
 }
Esempio n. 12
0
        public void Start(bool normalState)
        {
            if (_started)
            {
                throw new InvalidOperationException("Already started");
            }

            _started     = true;
            _normalState = normalState;

            CloudLog.Notice("Fire interface normal state set initialized at {0}",
                            _normalState ? "Closed" : "Open");

            _socket.Start();
        }
Esempio n. 13
0
        private void DigitalInputOnStateChange(DigitalInput digitalInput, DigitalInputEventArgs args)
        {
            CloudLog.Notice("Fire interface port state change: {0}", args.State ? "Closed" : "Open");

            if (!_started)
            {
                return;
            }

            OnStateChanged(this, args.State != _normalState);

            var message = string.Format("firestate[{0}]\r\n", args.State == _normalState ? "NORMAL" : "ALERT");
            var bytes   = Encoding.ASCII.GetBytes(message);

            _socket.SendToAll(bytes, 0, bytes.Length);
        }
        private object CodecPollingProcess(object userSpecific)
        {
            while (!_programStopping)
            {
                foreach (var valuePair in _codecAddresses)
                {
                    var roomId  = valuePair.Key;
                    var address = valuePair.Value;

                    try
                    {
                        var uri = new UriBuilder("https", address, 443, "status.xml").Uri;
                        Debug.WriteInfo("Polling Codec", "Room {0}: {1}", roomId, uri.ToString());
                        var request = new HttpsClientRequest {
                            Url = new UrlParser(uri.ToString())
                        };
                        var username = ConfigManager.Config.CodecUsername;
                        var password = ConfigManager.Config.CodecPassword;
                        var auth     = Convert.ToBase64String(Encoding.ASCII.GetBytes(username + ":" + password));
                        request.Header.AddHeader(new HttpsHeader("Authorization", "Basic " + auth));
                        var response = Client.Dispatch(request);
                        var reader   = new XmlReader(response.ContentString);
                        var doc      = XDocument.Load(reader);
                        var status   = doc.Element("Status");
                        Debug.WriteSuccess("Codec Online", status.Element("UserInterface").Element("ContactInfo").Element("Name").Value);
                        Debug.WriteSuccess("Mute", status.Element("Audio").Element("Microphones").Element("Mute").Value);
                        Debug.WriteSuccess("In Call", status.Elements("Call").Any().ToString());
                        Debug.WriteSuccess("Uptime", TimeSpan.FromSeconds(int.Parse(status.Element("SystemUnit").Element("Uptime").Value)).ToPrettyFormat());
                        Debug.WriteSuccess("Standby", "Status = {0}", status.Element("Standby").Element("State").Value != "Standby");
                        CrestronConsole.PrintLine("");
                    }
                    catch (Exception e)
                    {
                        CloudLog.Error("Error polling codec at {0}, {1}", address, e.Message);
                    }
                }

                Thread.Sleep(30000);
                CrestronEnvironment.AllowOtherAppsToRun();
            }

            CloudLog.Notice("Leaving thread: {0}", Thread.CurrentThread.Name);

            return(null);
        }
Esempio n. 15
0
        protected virtual void OnInitialized()
        {
            CloudLog.Notice("Tesira block {0} \"{1}\" OnInitialized()", GetType().Name, Name);
            var handler = HasInitialized;

            if (handler == null)
            {
                return;
            }
            try
            {
                handler(this);
            }
            catch (Exception e)
            {
                CloudLog.Exception(e);
            }
        }
Esempio n. 16
0
        public void Start()
        {
            if (_started)
            {
                CloudLog.Warn("{0} instance on TCP port {1}, already started", GetType().Name, _socket.PortNumber);
                return;
            }

            _started = true;

            try
            {
                CloudLog.Notice("Starting {0} instance on TCP port {1}", GetType().Name, _portNumber);

                if (_socket == null || _socket.ServerSocketStatus == SocketStatus.SOCKET_STATUS_SOCKET_NOT_EXIST)
                {
                    CloudLog.Info("Created new socket for {0} on port {1}", GetType().Name, _portNumber);
                    _socket = new TCPServer(IPAddress.Any.ToString(), _portNumber, _bufferSize,
                                            EthernetAdapterType.EthernetUnknownAdapter, _numberOfConnections);
                    _socket.SocketSendOrReceiveTimeOutInMs = 60000;
                    _socket.SocketStatusChange            += SocketOnSocketStatusChange;
                    if (_waitForConnectThread == null || _waitForConnectThread.ThreadState != Thread.eThreadStates.ThreadRunning)
                    {
                        _waitForConnectThread = new Thread(ListenForConnections, null)
                        {
                            Name     = string.Format("{0} Connection Handler", GetType().Name),
                            Priority = Thread.eThreadPriority.MediumPriority
                        };
                    }
                    CloudLog.Info("{0} on port {1}\r\nStatus: {2}\r\nMax Connections: {3}", GetType().Name,
                                  _socket.PortNumber, _socket.State, _socket.MaxNumberOfClientSupported);
                }
                else
                {
                    CloudLog.Warn("TCP Server. Could not start. Current Socket Status:{0}", _socket.ServerSocketStatus);
                }
            }
            catch (Exception e)
            {
                CloudLog.Exception(e, "Could not start socket");
            }
        }
Esempio n. 17
0
        object RxHandler(object o)
        {
            while (true)
            {
                try
                {
                    var bytes = _rxQueue.Dequeue();

                    if (bytes == null)
                    {
                        CloudLog.Notice("Bytes returned null. Program stopping? Exiting {0}", Thread.CurrentThread.Name);
                        return(null);
                    }

                    for (var i = 0; i < bytes.Length; i++)
                    {
                        switch (bytes[i])
                        {
                        case 10:
                            break;

                        case 13:
                            OnDataReceived(Encoding.ASCII.GetString(_bytes, 0, _byteIndex));
                            _byteIndex = 0;
                            break;

                        default:
                            _bytes[_byteIndex] = bytes[i];
                            _byteIndex++;
                            break;
                        }
                    }
                }
                catch (Exception ex)
                {
                    ErrorLog.Exception("Exception in Codec Rx thread:", ex);
                }

                CrestronEnvironment.AllowOtherAppsToRun();
                Thread.Sleep(0);
            }
        }
Esempio n. 18
0
 private void AirMediaOnAirMediaChange(object sender, GenericEventArgs args)
 {
     switch (args.EventId)
     {
     case Crestron.DeviceSupport.Support.AirMediaInputSlot.AirMediaImageErrorEventId:
         var error = ((AmX00)_device).AirMedia.DisplayControl.ImageErrorFeedback.UShortValue;
         if (error == 0)
         {
             CloudLog.Notice("AirMedia {0} background set to \"{1}\"", _device.ID.ToString("X2"),
                             ((AmX00)_device).AirMedia.DisplayControl.ImageURLFeedback.StringValue);
         }
         else
         {
             CloudLog.Error("AirMedia {0} could not set background to \"{1}\", Error {2}",
                            _device.ID.ToString("X2"),
                            ((AmX00)_device).AirMedia.DisplayControl.ImageURL.StringValue, error);
         }
         break;
     }
 }
Esempio n. 19
0
        object ReceiveBufferProcess(object obj)
        {
            var bytes     = new Byte[BufferLen];
            var byteIndex = 0;

            while (true)
            {
                try
                {
                    var b = _rxQueue.Dequeue();

                    if (_programStopping)
                    {
                        CloudLog.Notice("Exiting {0}", Thread.CurrentThread.Name);
                        return(null);
                    }

                    if (b == 0x0d)
                    {
                        OnReceivedString(Encoding.ASCII.GetString(bytes, 0, byteIndex));

                        byteIndex = 0;
                    }
                    else if (b != 0x0a)
                    {
                        bytes[byteIndex] = b;
                        byteIndex++;
                    }
                }
                catch (Exception e)
                {
                    if (e.Message != "ThreadAbortException")
                    {
                        CloudLog.Exception(string.Format("{0} - Exception in rx thread", GetType().Name), e);
                    }
                }

                CrestronEnvironment.AllowOtherAppsToRun();
                Thread.Sleep(0);
            }
        }
Esempio n. 20
0
        private void VersiportOnVersiportChange(Versiport port, VersiportEventArgs args)
        {
            if (args.Event == eVersiportEvent.DigitalInChange)
            {
                CloudLog.Notice("Fire interface port state change: {0}", port.DigitalIn ? "Closed" : "Open");
            }
            else
            {
                return;
            }

            if (!_started)
            {
                return;
            }

            OnStateChanged(this, port.DigitalIn != _normalState);

            var message = string.Format("firestate[{0}]\r\n", port.DigitalIn == _normalState ? "NORMAL" : "ALERT");
            var bytes   = Encoding.ASCII.GetBytes(message);

            _socket.SendToAll(bytes, 0, bytes.Length);
        }
Esempio n. 21
0
        private void FireAlarmListenerOnStatusChanged(FireAlarmListener listener, FireAlarmStatus status)
        {
            var mute = status == FireAlarmStatus.Alert;

            CloudLog.Warn("Fire Alarm Interface changed status to: {0}", status.ToString());

            try
            {
                PromptUsers(prompt => { }, "FIRE ALARM", "Please listen for announcements", 300, null,
                            new PromptAction
                {
                    ActionName = "OK",
                    ActionType = PromptActionType.Acknowledge
                });
            }
            catch (Exception e)
            {
                CloudLog.Exception(e);
            }

            if (Dsp != null && Dsp.ContainsComponentWithName("fire.mute"))
            {
                var muteGainBlock = Dsp["fire.mute"] as IAudioLevelControl;
                if (muteGainBlock != null && muteGainBlock.SupportsMute)
                {
                    CloudLog.Notice("Dsp mute {0} set to {1}", muteGainBlock.Name, mute ? "muted" : "unmuted");
                    muteGainBlock.Muted = mute;
                    return;
                }
            }

            foreach (var room in Rooms.Cast <ARoom>().Where(room => room.ProgramVolume != null))
            {
                CloudLog.Warn("Fire Alarm {0} program volume in Room {1}", mute ? "muted" : "unmuted", room.Name);
                room.ProgramVolume.Muted = mute;
            }
        }
Esempio n. 22
0
 private void InternalClockInitialize()
 {
     _clockInitThread = new Thread(specific =>
     {
         CloudLog.Debug("InternalClockInitialize(), Waiting for seconds to be 0", GetType().Name);
         while (DateTime.Now.Second != 0)
         {
             Thread.Sleep(50);
             CrestronEnvironment.AllowOtherAppsToRun();
         }
         CloudLog.Notice("InternalClockInitialize(), Seconds should now be zero, time is now {1}, creating CTimer to track time",
                         GetType().Name,
                         DateTime.Now.ToString("T"));
         _clockTimer = new CTimer(s => OnTimeChange(), null, 60000, 60000);
         OnTimeChange();
         CloudLog.Info("InternalClockInitialize(), OnTimeChange() will be called every time time is 0 seconds", GetType().Name);
         return(null);
     }, null, Thread.eThreadStartOptions.CreateSuspended)
     {
         Name     = "Clock Init Thread",
         Priority = Thread.eThreadPriority.HighPriority
     };
     _clockInitThread.Start();
 }
Esempio n. 23
0
        private object ListenForConnections(object userSpecific)
        {
            CloudLog.Notice("Started {0} connection handler", GetType().Name);

            while (!_programStopping)
            {
                CloudLog.Debug("{0} Waiting for connections...", GetType().Name);

                if (_socket.NumberOfClientsConnected < _socket.MaxNumberOfClientSupported)
                {
                    var result = _socket.WaitForConnection();
                    CloudLog.Debug("{0} Connection result: {1}", GetType().Name, result);
                }
                else
                {
                    CloudLog.Debug("{0} No more connections allowed", GetType().Name);
                    Thread.Sleep(10000);
                }
            }

            CloudLog.Notice("Exiting {0}", Thread.CurrentThread.Name);

            return(null);
        }
        private object UpdateFeedbackProcess(object userSpecific)
        {
            CloudLog.Notice("Started " + Thread.CurrentThread.Name);

            var feedback = true;

            var itemStates = new Dictionary <RoutingListItem, ItemState>();

            while (RequestedVisibleState && !_programStopping && _switcher.Chassis.IsOnline)
            {
                if (_selectedInput != null)
                {
                    _routedOutputsForSelectedInput = new List <DMOutput>();
                    foreach (
                        var output in
                        _switcher.Chassis.Outputs.Values.Where(
                            o => o.VideoOutFeedback != null && o.VideoOutFeedback == _selectedInput))
                    {
                        _routedOutputsForSelectedInput.Add(output);
                    }

                    foreach (var item in _outputList.Cast <RoutingListItem>().TakeWhile(item => item.LinkedObject != null))
                    {
                        var output        = (DMOutput)item.LinkedObject;
                        var alreadyRouted = _routedOutputsForSelectedInput.Contains(output);
                        var willChange    = _outputsToChange.Keys.Contains(output);

                        itemStates[item] = new ItemState {
                            Color = RoutingItemListColor.Blue, Feedback = false
                        };

                        if (alreadyRouted && willChange)
                        {
                            itemStates[item].Color    = RoutingItemListColor.Red;
                            itemStates[item].Feedback = feedback;
                        }
                        else if (willChange && _outputsToChange[output] == _selectedInput)
                        {
                            itemStates[item].Color    = RoutingItemListColor.Green;
                            itemStates[item].Feedback = feedback;
                        }
                        else if (alreadyRouted)
                        {
                            itemStates[item].Feedback = true;
                        }
                    }
                }
                else
                {
                    foreach (var item in _outputList.Cast <RoutingListItem>().TakeWhile(item => item.LinkedObject != null))
                    {
                        itemStates[item] = new ItemState {
                            Color = RoutingItemListColor.Blue, Feedback = false
                        };
                    }
                }

                foreach (var itemState in itemStates)
                {
                    itemState.Key.Feedback = itemState.Value.Feedback;
                    itemState.Key.Color    = itemState.Value.Color;
                }

                _cancelButton.Enabled = _outputsToChange.Count > 0 || _selectedInput != null;
                _takeButton.Enabled   = _outputsToChange.Count > 0;

                if (_updateFeedbackEvent.Wait(500))
                {
                    feedback = true;
                }
                else
                {
                    feedback = !feedback;
                }
            }

            if (RequestedVisibleState)
            {
                Debug.WriteInfo("Showing DM offline prompt on " + UIController.ToString());
                ((BaseUIController)UIController).ActionSheetDefault.Show((type, args) => { }, "Switcher Offline",
                                                                         "The DM Switcher is offline", "OK");
            }

            CloudLog.Notice("Exiting " + Thread.CurrentThread.Name);

            return(null);
        }
Esempio n. 25
0
        protected object ConnectionThreadProcess(object o)
        {
            var memoryStream     = new MemoryStream();
            var reader           = new StreamReader(memoryStream);
            var receivedAnything = false;

            while (true)
            {
                var connectCount = 0;
                while (_remainConnected && !Connected)
                {
                    connectCount++;
                    _client.AddressClientConnectedTo = _currentAddress;
                    Debug.WriteInfo(GetType().Name, "Address to connect to set to {0}", _currentAddress);
                    var result = _client.ConnectToServer();
                    if (result == SocketErrorCodes.SOCKET_OK)
                    {
                        CloudLog.Notice("{0} connected to {1}", GetType().Name, _client.AddressClientConnectedTo);
                        receivedAnything = false;
                        break;
                    }

                    TryAnotherAddress();

                    if (connectCount <= 4 || connectCount > 10)
                    {
                        continue;
                    }

                    if (connectCount == 10)
                    {
                        CloudLog.Error("{0} failed to connect to any address, will keep trying in background",
                                       GetType().Name);
                    }
                    else
                    {
                        CloudLog.Warn("{0} cannot connect to address: {1}", GetType().Name, _currentAddress);
                    }

                    CrestronEnvironment.AllowOtherAppsToRun();
                }

                _pollTimer = new CTimer(specific => DoNothing(), null, 30000, 30000);

                _adapterType = _client.EthernetAdapter;

                while (true)
                {
                    var dataCount = _client.ReceiveData();

                    if (dataCount <= 0)
                    {
                        Debug.WriteWarn(GetType().Name, "Disconnected!");
                        _pollTimer.Stop();
                        _pollTimer.Dispose();
                        _pollTimer = null;

                        if (_remainConnected)
                        {
                            if (!receivedAnything)
                            {
                                CloudLog.Warn(
                                    "{0} connected but didn't receive anything." +
                                    "Will wait for 1 minute before reconnection attempt. Upgrade may be in progress.",
                                    GetType().Name);
                                Thread.Sleep(60000);
                            }
                            break;
                        }

                        Debug.WriteWarn("Exiting Thread", Thread.CurrentThread.Name);
                        return(null);
                    }

                    receivedAnything = true;
#if DEBUG
                    Debug.WriteInfo(GetType().Name, "{0} bytes in buffer", dataCount);
#endif
                    for (var i = 0; i < dataCount; i++)
                    {
                        var b = _client.IncomingDataBuffer[i];
                        if (b != 0)
                        {
                            memoryStream.WriteByte(b);
                            continue;
                        }

                        memoryStream.Position = 0;
                        try
                        {
                            var data = JToken.Parse(reader.ReadToEnd());
                            memoryStream.SetLength(0);
#if DEBUG
                            Debug.WriteInfo(_name + " Rx",
                                            Debug.AnsiBlue + data.ToString(Formatting.None) + Debug.AnsiReset);
#endif
                            if (data["method"] != null)
                            {
                                OnRequestReceived(this, new QsysRequest(data));
                            }
                            else if (data["id"] != null)
                            {
                                var id = data["id"].Value <int>();
                                if (_requests.ContainsKey(id))
                                {
                                    var request = _requests[id];
                                    _requests.Remove(id);
                                    OnResponseReceived(this, new QsysResponse(data, request));
                                }
                            }
                        }
                        catch (Exception e)
                        {
                            CloudLog.Exception("Error occured processing a complete data parcel from Core", e);
                        }
                    }

                    CrestronEnvironment.AllowOtherAppsToRun();
                    Thread.Sleep(0);
                }
            }
        }
Esempio n. 26
0
        public void ConnectionStart()
        {
            if (_connectionId > 0 || (_connectionThread != null && _connectionThread.ThreadState == Thread.eThreadStates.ThreadRunning))
            {
                return;
            }
            _connectionActive = true;
            _connectionWait.Reset();
            CloudLog.Notice("{0} Initialize() called", GetType().Name);
            _connectionThread = new Thread(specific =>
            {
                while (_connectionActive && !_programStopping)
                {
                    var suppressErrors = false;

                    UriBuilder uri;
                    Task <HttpResponseMessage> task;
                    HttpResponseMessage response;
                    Task <string> readTask;
                    string content;
                    JToken json;

                    while (_connectionId == 0)
                    {
                        try
                        {
                            uri = new UriBuilder("http", _ipAddress, 80, string.Format("config"))
                            {
                                Query = "action=connect"
                            };

                            Debug.WriteInfo("Trying to connect to " + uri.Uri);

                            task     = _client.GetAsync(uri.Uri);
                            response = task.Await();

                            response.EnsureSuccessStatusCode();

                            readTask = response.Content.ReadAsStringAsync();
                            content  = readTask.Await();
#if DEBUG
                            Debug.WriteInfo("Response content:\r\n" + content);
#endif
                            json = JToken.Parse(content);

                            _connectionId = int.Parse(json["connectionid"].Value <string>());
                            CloudLog.Debug("{0} connected and received conenction id of \"{1}\"", GetType().Name,
                                           _connectionId);

                            try
                            {
                                var eventInfo   = json["configevents"].First;
                                _currentClip    = eventInfo["eParamID_CurrentClip"].Value <string>();
                                _transportState =
                                    (ETransportState)int.Parse(eventInfo["eParamID_TransportState"].Value <string>());
                                OnTransportModeChanged(this);
                            }
                            catch (Exception e)
                            {
                                Debug.WriteWarn("Could not parse configevents on connect, {0}", e.Message);
                            }
                        }
                        catch (Exception e)
                        {
                            if (!suppressErrors)
                            {
                                suppressErrors = true;
                                CloudLog.Error("Error trying to connect to {0}, {1}", GetType().Name, e.Message);
                                CloudLog.Warn("{0} will try again in 5 seconds", GetType().Name);
                            }

                            _connectionWait.Wait(5000);

                            DeviceCommunicating = false;
                        }
                    }

                    DeviceCommunicating = true;

                    uri = new UriBuilder("http", _ipAddress, 80, string.Format("config"))
                    {
                        Query = "action=get&paramid=eParamID_TransportState"
                    };

                    Debug.WriteInfo("Trying to connect to " + uri.Uri);

                    task     = _client.GetAsync(uri.Uri);
                    response = task.Await();

                    response.EnsureSuccessStatusCode();
                    readTask = response.Content.ReadAsStringAsync();
                    content  = readTask.Await();
#if DEBUG
                    Debug.WriteWarn("Response content:\r\n" + content);
#endif
                    json = JToken.Parse(content);

                    TransportState = (ETransportState)int.Parse(json["value"].Value <string>());

                    while (_connectionActive)
                    {
                        var timeStamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;

                        uri = new UriBuilder("http", _ipAddress, 80, string.Format("config"))
                        {
                            Query =
                                string.Format("action=wait_for_config_events&connectionid={0}&_={1}", _connectionId,
                                              timeStamp)
                        };

                        Debug.WriteInfo("Trying to connect to " + uri.Uri);

                        task     = _client.GetAsync(uri.Uri);
                        response = task.Await();

                        if (response.StatusCode == HttpStatusCode.Gone)
                        {
                            _connectionId = 0;
                            break;
                        }

                        response.EnsureSuccessStatusCode();
                        readTask = response.Content.ReadAsStringAsync();
                        content  = readTask.Await();
#if DEBUG
                        Debug.WriteWarn("Response content:\r\n" + content);
#endif
                        json = JToken.Parse(content);

                        foreach (var item in json)
                        {
                            var paramId = item["param_id"].Value <string>();
                            switch (paramId)
                            {
                            case "eParamID_DisplayTimecode":
                                _timeCode = item["str_value"].Value <string>();
                                break;

                            case "eParamID_CurrentClip":
                                _currentClip = item["str_value"].Value <string>();
                                break;

                            case "eParamID_TransportState":
                                _transportState = (ETransportState)item["int_value"].Value <int>();
                                break;
                            }
                        }

                        OnTransportModeChanged(this);

                        CrestronEnvironment.AllowOtherAppsToRun();

                        _connectionWait.Wait(100);
                    }
                }

                _connectionId = 0;

                return(null);
            }, null);
        }
Esempio n. 27
0
        private void SshClientOnReceivedData(CiscoSshClient client, CodecSshClientReceivedDataArgs args)
        {
            var matches = Regex.Matches(args.DataAsReceived,
                                        @"\*\w ([^\r\n\""\:]+) (\w+)?(?:\(([\w\=]+)\))?:? ?\""?([^\r\n\""]+)?\""?");

            if (matches.Count <= 0)
            {
                return;
            }

            switch (args.DataType)
            {
            case ReceivedDataType.Configuration:
                foreach (Match configMatch in matches)
                {
                    try
                    {
                        OnConfigurationChanged(this, new ConfigurationChangeEventArgs
                        {
                            Path         = configMatch.Groups[1].Value,
                            PropertyName = configMatch.Groups[2].Value,
                            Value        = configMatch.Groups[4].Value
                        });
                    }
                    catch (Exception e)
                    {
                        CloudLog.Exception(e);
                    }
                }
                break;

            case ReceivedDataType.Status:
                OnStatusReceived((from Match statusMatch in matches
                                  select new StatusUpdateItem(statusMatch))
                                 .ToArray());
                if (_initialized)
                {
                    return;
                }
                CloudLog.Notice("{0} Initialized OK", this);
                _initialized = true;
                break;

            case ReceivedDataType.Event:
                var items = new Dictionary <string, Dictionary <string, string> >();
                foreach (Match eventMatch in matches)
                {
                    if (!items.ContainsKey(eventMatch.Groups[1].Value))
                    {
                        items.Add(eventMatch.Groups[1].Value, new Dictionary <string, string>());
                    }

                    if (eventMatch.Groups[4].Success)
                    {
                        items[eventMatch.Groups[1].Value][eventMatch.Groups[2].Value] = eventMatch.Groups[4].Value;
                    }
                    else
                    {
                        items[eventMatch.Groups[1].Value][eventMatch.Groups[2].Value] = string.Empty;
                    }
                }

                foreach (var item in items)
                {
                    OnEventReceived(item.Key, item.Value);
                }
                break;

            case ReceivedDataType.Response:
                foreach (Match response in matches)
                {
#if DEBUG
                    Debug.WriteInfo("Response", "{0} {1} {2}",
                                    response.Groups[1].Value,
                                    response.Groups[2].Value,
                                    response.Groups[3].Value);
#endif
                }
                break;
            }
        }
Esempio n. 28
0
        private object SshCommsProcess(object userSpecific)
        {
            try
            {
                Thread.Sleep(1000);

                Debug.WriteInfo(string.Format("{0} attempting connection to {1}", GetType().Name, _address));

                var firstFail = false;

                while (!_client.IsConnected && _reconnect)
                {
                    try
                    {
                        ConnectionStatus = ClientStatus.AttemptingConnection;
                        _client.Connect();
                    }
                    catch
                    {
                        ConnectionStatus = ClientStatus.Disconnected;
                        if (!firstFail)
                        {
                            CloudLog.Warn("{0} could not connect to {1}, will retry every 30 seconds until connected",
                                          GetType().Name, _address);
                            firstFail = true;
                        }
                        Thread.Sleep(30000);
                    }
                }

                if (!_client.IsConnected && !_reconnect)
                {
                    _client.Dispose();
                    _client          = null;
                    ConnectionStatus = ClientStatus.Disconnected;
                    return(null);
                }

                CloudLog.Notice("{0} Connected to {1}", GetType().Name, _address);

                _shell = _client.CreateShellStream("terminal", 80, 24, 800, 600, BufferSize);

                var buffer    = new byte[BufferSize];
                var dataCount = 0;

                try
                {
                    while (_programRunning && _client.IsConnected)
                    {
                        while (_shell.CanRead && _shell.DataAvailable)
                        {
                            var incomingData      = new byte[BufferSize];
                            var incomingDataCount = _shell.Read(incomingData, 0, incomingData.Length);
#if DEBUG
                            _stopWatch.Start();
                            Debug.WriteSuccess("Tesira rx {0} bytes", incomingDataCount);
                            //Debug.WriteNormal(Debug.AnsiBlue +
                            //                  Tools.GetBytesAsReadableString(incomingData, 0, incomingDataCount, true) +
                            //                  Debug.AnsiReset);
#endif
                            if (!Connected &&
                                Encoding.ASCII.GetString(incomingData, 0, incomingDataCount)
                                .Contains("Welcome to the Tesira Text Protocol Server..."))
                            {
                                _requestsSent.Clear();
                                _requestsAwaiting.Clear();
                                _sendQueue.Enqueue("SESSION set verbose true");
                                ConnectionStatus = ClientStatus.Connected;
                                _keepAliveTimer  = new CTimer(specific =>
                                {
#if DEBUG
                                    Debug.WriteInfo(GetType().Name + " Sending KeepAlive");
#endif
                                    _client.SendKeepAlive();
                                }, null, KeepAliveTime, KeepAliveTime);
                            }
                            else if (Connected)
                            {
                                for (var i = 0; i < incomingDataCount; i++)
                                {
                                    buffer[dataCount] = incomingData[i];

                                    if (buffer[dataCount] == 10)
                                    {
                                        //skip
                                    }
                                    else if (buffer[dataCount] != 13)
                                    {
                                        dataCount++;
                                    }
                                    else
                                    {
                                        if (dataCount == 0)
                                        {
                                            continue;
                                        }

                                        var line = Encoding.UTF8.GetString(buffer, 0, dataCount);
                                        dataCount = 0;
#if DEBUG
                                        Debug.WriteSuccess("Tesira Rx Line", Debug.AnsiPurple + line + Debug.AnsiReset);
#endif
                                        TesiraMessage message = null;

                                        if (line == "+OK")
                                        {
                                            var request = _requestsAwaiting.TryToDequeue();
                                            if (request != null)
                                            {
#if DEBUG
                                                Debug.WriteInfo("Request Response Received", request);
                                                Debug.WriteSuccess(line);
#endif
                                                message = new TesiraResponse(request, null);
                                            }
                                        }
                                        else if (line.StartsWith("+OK "))
                                        {
                                            var request = _requestsAwaiting.TryToDequeue();
                                            if (request != null)
                                            {
#if DEBUG
                                                Debug.WriteInfo("Request Response Received", request);
                                                Debug.WriteSuccess(line);
#endif
                                                message = new TesiraResponse(request, line.Substring(4));
                                            }
                                        }
                                        else if (line.StartsWith("-ERR "))
                                        {
                                            var request = _requestsAwaiting.TryToDequeue();
                                            if (request != null)
                                            {
#if DEBUG
                                                Debug.WriteInfo("Request Response Received", request);
                                                Debug.WriteError(line);
#endif
                                                message = new TesiraErrorResponse(request, line.Substring(5));
                                            }
                                            else
                                            {
                                                Debug.WriteError("Error received and request queue returned null!");
                                                Debug.WriteError(line);
                                                Debug.WriteError("Clearing all queues!");
                                                _requestsSent.Clear();
                                                _requestsAwaiting.Clear();
                                            }
                                        }
                                        else if (line.StartsWith("! "))
                                        {
#if DEBUG
                                            Debug.WriteWarn("Notification Received");
                                            Debug.WriteWarn(line);
#endif
                                            message = new TesiraNotification(line.Substring(2));
                                        }
                                        else if (!_requestsSent.IsEmpty)
                                        {
                                            Debug.WriteWarn("Last sent request", _requestsSent.Peek());

                                            if (_requestsSent.Peek() == line)
                                            {
                                                _requestsAwaiting.Enqueue(_requestsSent.Dequeue());
#if DEBUG
                                                Debug.WriteNormal("Now awaiting for response for command", line);
#endif
                                            }
                                        }

                                        if (message != null && ReceivedData != null && message.Type != TesiraMessageType.ErrorResponse)
                                        {
                                            if (ReceivedData == null)
                                            {
                                                continue;
                                            }
                                            try
                                            {
                                                _timeOutCount = 0;

                                                ReceivedData(this, message);
                                            }
                                            catch (Exception e)
                                            {
                                                CloudLog.Exception(e, "Error calling event handler");
                                            }
                                        }
                                        else if (message != null && message.Type == TesiraMessageType.ErrorResponse)
                                        {
                                            _timeOutCount = 0;

                                            CloudLog.Error("Error message from Tesira: \"{0}\"", message.Message);
                                        }
                                    }
                                }
                            }
#if DEBUG
                            _stopWatch.Stop();
                            Debug.WriteNormal("Time to process: {0} ms", _stopWatch.ElapsedMilliseconds);
                            _stopWatch.Reset();
#endif
                            CrestronEnvironment.AllowOtherAppsToRun();
                        }

                        if (!_programRunning || !_client.IsConnected)
                        {
                            break;
                        }
#if DEBUG
                        //Debug.WriteNormal(Debug.AnsiBlue +
                        //                  string.Format(
                        //                      "Shell Can Write = {0}, _sendQueue = {1}, _requestsSent = {2}, _requestsAwaiting = {3}",
                        //                      _shell.CanWrite, _sendQueue.Count, _requestsSent.Count,
                        //                      _requestsAwaiting.Count) + Debug.AnsiReset);
#endif
                        if (_shell.CanWrite && !_sendQueue.IsEmpty && _requestsSent.IsEmpty && _requestsAwaiting.IsEmpty)
                        {
                            var s = _sendQueue.Dequeue();

                            if (_keepAliveTimer != null && !_keepAliveTimer.Disposed)
                            {
                                _keepAliveTimer.Reset(KeepAliveTime, KeepAliveTime);
                            }
#if DEBUG
                            Debug.WriteWarn("Tesira Tx", s);
#endif
                            _timeOutCount = 0;
                            _shell.WriteLine(s);
                            _requestsSent.Enqueue(s);
                            Thread.Sleep(20);
                        }
                        else if (!_requestsSent.IsEmpty || !_requestsAwaiting.IsEmpty)
                        {
                            _timeOutCount++;

                            if (_timeOutCount > 100)
                            {
                                CloudLog.Warn(
                                    "Error waiting to send requests in {0}, _requestsAwaiting.Count = {1}" +
                                    "and _requestsSent.Count = {2}. Clearing queues!",
                                    GetType().Name, _requestsAwaiting.Count, _requestsSent.Count);
                                _requestsAwaiting.Clear();
                                _requestsSent.Clear();
                                _timeOutCount = 0;
                            }

                            Thread.Sleep(20);
                        }
                    }
                }
                catch (Exception e)
                {
                    CloudLog.Exception(e);
                }

                _loggedIn = false;

                if (_keepAliveTimer != null && !_keepAliveTimer.Disposed)
                {
                    _keepAliveTimer.Stop();
                    _keepAliveTimer.Dispose();
                    _keepAliveTimer = null;
                }

                if (_client != null && _client.IsConnected)
                {
                    _client.Dispose();
                    _client = null;
                }

                CloudLog.Notice("{0} Disconnected from {1}", GetType().Name, _address);
            }
            catch (Exception e)
            {
                CloudLog.Exception(e, "Error in {0}.SshCommsProcess()", GetType().Name);
            }

            ConnectionStatus = ClientStatus.Disconnected;

            if (!_reconnect || !_programRunning)
            {
                return(null);
            }

            Thread.Sleep(1000);

            CloudLog.Notice("Attempting reconnect to Tesira at {0}", _address);
            ConnectionStatus = ClientStatus.AttemptingConnection;

            Connect();

            return(null);
        }
Esempio n. 29
0
 protected void StartWebApp(int portNumber)
 {
     CloudLog.Notice("Starting web app on port {0}", portNumber);
     _webApp = new WebApp.WebApp(this, portNumber);
     OnWebAppStarted();
 }
Esempio n. 30
0
        internal bool StartSession()
        {
            CodecRequest  request;
            CodecResponse response;

            CloudLog.Info("Cisco Codec StartSession() called");

            if (!string.IsNullOrEmpty(_sessionId))
            {
                try
                {
                    CloudLog.Debug("Codec has session ID already... attempting to close it");

                    request = new CodecRequest(_address, "/xmlapi/session/end", _sessionId)
                    {
                        RequestType = RequestType.Post
                    };
                    response = Dispatch(request);
#if DEBUG
                    Debug.WriteInfo("Received headers for session end:\r\n" + response.Header);
#endif
                    CloudLog.Debug("Session close request result: {0}", response.Code);
                }
                catch (Exception e)
                {
                    Debug.WriteError("Error trying to close session on codec",
                                     "Session ID to close: {0}, Error: {1}\r\nStackTrace: {2}", _sessionId, e.Message, e.StackTrace);
                    CloudLog.Error("Error trying to close the codec session, {0}", e.Message);
                }
            }
            try
            {
                request = new CodecRequest(_address, "/xmlapi/session/begin", _username, _password)
                {
                    RequestType = RequestType.Post
                };

                response = Dispatch(request);
#if DEBUG
                Debug.WriteInfo("Received headers for session begin:\r\n" + response.Header);
#endif
                if (response.Code == 401)
                {
                    CloudLog.Error("Error logging into Cisco Codec at \"{0}\" 401 - Unauthorized", _address);
                    return(false);
                }

                if (response.Code == 204)
                {
                    if (!response.Header.ContainsHeaderValue("Set-Cookie"))
                    {
                        CloudLog.Error("Received 204 for Session ID but response headers contained no Cookie");
                        return(false);
                    }
                    Debug.WriteSuccess("Codec Set-Cookie received", response.Header["Set-Cookie"]);
                    CloudLog.Notice("Codec Set-Cookie received\r\n{0}", response.Header["Set-Cookie"]);
                    var match = Regex.Match(response.Header["Set-Cookie"].Value, @"(.*?)=(.*?);");
                    if (match.Groups[1].Value != "SecureSessionId")
                    {
                        CloudLog.Error("Received 204 for Session ID but response headers contained no SessionId");
                        return(false);
                    }
                    _sessionId = match.Groups[2].Value;

                    CloudLog.Info("Codec received new Session Id OK");
                    return(true);
                }
            }
            catch (Exception e)
            {
                CloudLog.Error("Error trying to get a session ID from Cisco Codec, {0}", e.Message);
                return(false);
            }
            return(false);
        }