示例#1
0
        /// <summary>
        /// Check Connection button is clicked
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void BtnCheck_Click(object sender, RoutedEventArgs e)
        {
#if DEBUG
            if (Keyboard.IsKeyDown(Key.LeftCtrl) || Keyboard.IsKeyDown(Key.RightCtrl))
            {
                OnConnectionReady?.Invoke(true);
                return;
            }
#endif
            try
            {
                OnConnectionReady?.Invoke(false);

                pnlPrgress.Visibility  = Visibility.Visible;
                pnlPrgress.DataContext = AppStrings.Msg_TryConnecting;

                await _theta.CheckConnection();

                pnlPrgress.Visibility = Visibility.Collapsed;

                await LoadStatusAndInfo();

                OnShowMessage?.Invoke(AppStrings.Msg_ConnectionOK);

                OnConnectionReady?.Invoke(true);
            }
            catch (ThetaWifiConnectException connex)
            {
                // Connecton error...
                pnlPrgress.Visibility = Visibility.Collapsed;
                HandleError(connex);
            }
            finally
            {
            }
        }
示例#2
0
        protected void HandleMessage(byte[] message, OfpHeader header)
        {
            //state = null;
            MemoryStream ms = new MemoryStream(message);

            //var header = ParesHeader(ms);
            if (header == null)
            {
                return;
            }

            _log.Debug($"[{_mac}] message={header.Type.ToString()}");
            //Console.WriteLine($"[{_mac}] message={header.Type.ToString()}");

            if (!_inited)
            {
                Initialize(ms, header);
                if (_versionChecked && _configChecked && _featureChecked)
                {
                    _inited = true;
                    _log.Info($"[{_mac}] inited.");
                    //Console.WriteLine($"[{_mac}] inited.");
                    OnConnectionReady?.Invoke(this);
                }
                return;
            }

            switch (header.Type)
            {
            case OfpType.OFPT_HELLO:
                Hello(ms, header);
                break;

            case OfpType.OFPT_ERROR:
                Error(ms, header);
                break;

            case OfpType.OFPT_ECHO_REQUEST:
                Echo(ms, header);
                break;

            case OfpType.OFPT_ECHO_REPLY:
                Echo(ms, header);
                break;

            case OfpType.OFPT_VENDOR:
                Vendor(ms, header);
                break;

            case OfpType.OFPT_FEATURES_REQUEST:
                Features(ms, header);
                break;

            case OfpType.OFPT_FEATURES_REPLY:
                Features(ms, header);
                break;

            case OfpType.OFPT_GET_CONFIG_REQUEST:
                SwitchConfig(ms, header);
                break;

            case OfpType.OFPT_GET_CONFIG_REPLY:
                SwitchConfig(ms, header);
                break;

            case OfpType.OFPT_SET_CONFIG:
                SwitchConfig(ms, header);
                break;

            case OfpType.OFPT_PACKET_IN:
                PacketIn(ms, header);
                break;

            case OfpType.OFPT_FLOW_REMOVED:
                FlowRemoved(ms, header);
                break;

            case OfpType.OFPT_PORT_STATUS:
                PortStatus(ms, header);
                break;

            case OfpType.OFPT_PACKET_OUT:
                PacketOut(ms, header);
                break;

            case OfpType.OFPT_FLOW_MOD:
                FlowMod(ms, header);
                break;

            case OfpType.OFPT_PORT_MOD:
                //NotImplemented
                break;

            case OfpType.OFPT_STATS_REQUEST:
                Stats(ms, header);
                break;

            case OfpType.OFPT_STATS_REPLY:
                Stats(ms, header);
                break;

            case OfpType.OFPT_BARRIER_REQUEST:
                Barrier(ms, header);
                break;

            case OfpType.OFPT_BARRIER_REPLY:
                Barrier(ms, header);
                break;

            case OfpType.OFPT_QUEUE_GET_CONFIG_REQUEST:
                QueueConfig(ms, header);
                break;

            case OfpType.OFPT_QUEUE_GET_CONFIG_REPLY:
                QueueConfig(ms, header);
                break;

            default:
                throw new ArgumentOutOfRangeException();
            }
            ms.Close();
        }