예제 #1
0
 private void Connect(ClientConnection connection)
 {
     if (connection.Client.State == ClientState.Disconnected)
     {
         connection.Connect();
     }
 }
예제 #2
0
        public static void Send(string server, int port, IMessage message)
        {
            ClientConnection connection = new ClientConnection();

            connection.Connect(server, port);
            connection.Send(message);
            connection.Disconnect();
        }
예제 #3
0
        public void Run(string command)
        {
            string[] args = command.Trim().Split(' ');
            string   host = args[0];
            int      port = int.Parse(args[1]);

            ClientMessage.Info($"Connecting to {host}:{port}...");
            ClientConnection.Connect(host, port);
        }
예제 #4
0
        public static T Send <T>(string server, int port, IMessage message) where T : IMessage
        {
            ClientConnection connection = new ClientConnection();

            connection.Connect(server, port);
            T response = connection.Send <T>(message);

            connection.Disconnect();
            return(response);
        }
예제 #5
0
        public static T Send <T>(string server, int port, int txRxTimeout, IMessage message) where T : IMessage
        {
            SocketTransport transport = new SocketTransport {
                SendTimeout = txRxTimeout, ReceiveTimeout = txRxTimeout
            };
            ClientConnection connection = new ClientConnection(transport);

            connection.Connect(server, port);
            T response = connection.Send <T>(message);

            connection.Disconnect();
            return(response);
        }
예제 #6
0
        public bool Connect(string address, int port)
        {
            if (mClientConnection.IsConnected() == 1)
            {
                return(true);
            }
            bool isConnected = mClientConnection.Connect(address, port);

            if (isConnected)
            {
                mMessageSchedulerTask = mScheduler.StartCoroutine(MessageScheduler());
            }
            return(isConnected);
        }
예제 #7
0
        public void When_connecting_to_the_server_endpoint_will_get_error()
        {
            var configuration = new InMemoryRavenConfiguration
            {
                RunInMemory = true
            };

            configuration.Initialize();
            using (new RavenMqServer(configuration))
                using (var c = new ClientConnection(new IPEndPoint(IPAddress.Loopback, 8181), new CaptureClientIntegration()))
                {
                    var e = Assert.Throws <AggregateException>(() => c.Connect().Wait());
                    Assert.Equal("Invalid response signature from server", e.InnerException.Message);
                }
        }
예제 #8
0
        public void Can_get_notificaton_from_server()
        {
            connection.Start();

            var clientIntegration = new CaptureClientIntegration();

            using (var clientConnection = new ClientConnection(new IPEndPoint(IPAddress.Loopback, 8181), clientIntegration))
            {
                clientConnection.Connect().Wait();

                clientIntegration.MessageArrived.WaitOne();

                Assert.Equal("{\"Pong\":\"Ping\"}", clientIntegration.Msgs[0].ToString(Formatting.None));
            }
        }
예제 #9
0
        //========== CONNECTION ==========
        #region Connection

        /**<summary>Attempts to connect to the host.</summary>*/
        private void ClientConnect()
        {
            // Validate input
            int       port = Config.Syncing.ClientPort;
            IPAddress ip   = IPAddress.Loopback;

            if (Config.Syncing.ClientIPAddress != "" && !IPAddress.TryParse(Config.Syncing.ClientIPAddress, out ip))
            {
                TriggerMessageBox.Show(this, MessageIcon.Warning, "The entered IP address in invalid!", "Invalid IP");
                return;
            }
            if (Config.Syncing.ClientUsername == "")
            {
                TriggerMessageBox.Show(this, MessageIcon.Warning, "Cannot connect with an empty username!", "Invalid Username");
                return;
            }

            // Connect to the host
            client = new ClientConnection();
            client.MessageReceived += OnClientMessageReceived;
            client.ConnectionLost  += OnClientConnectionLost;
            if (!client.Connect(ip, port))
            {
                TriggerMessageBox.Show(this, MessageIcon.Warning, "Failed to connect to server!", "Connection Failed");
                client = null;
            }
            else
            {
                // Final setup before waiting to login
                // Set the control states
                Dispatcher.Invoke(() => {
                    comboBoxSyncType.IsEnabled      = false;
                    textBoxClientIP.IsEnabled       = false;
                    numericClientPort.IsEnabled     = false;
                    textBoxClientUsername.IsEnabled = false;
                    textBoxClientPassword.IsEnabled = false;
                    textBoxClientNextSong.IsEnabled = false;
                    buttonClientConnect.IsEnabled   = false;
                    buttonClientConnect.Content     = "Connecting...";
                });

                clientTimeout.Start();

                client.Send(new StringCommand(Commands.Login, Config.Syncing.ClientUsername, Config.Syncing.ClientPassword));
            }
        }
예제 #10
0
        private void btnConnect_Click(object sender, EventArgs e)
        {
            if (!_connection.IsConnected)
            {
                ipAddress = cmbIPAddresses.Text;
                _connection.Connect(ipAddress, Port);
                if (_connection.IsConnected)
                {
                    Properties.Settings.Default.IPanalyzer = ipAddress;
                    Properties.Settings.Default.Save();      //persist ipaddress that works

                    chkEnableSignalGenerator.Enabled = true; // Enable checkbox;
                    _signalGenator.Enabled           = false;
                    btnConnect.Text             = "Disconnect";
                    btnConnect.BackColor        = Color.LightGreen;
                    btnStartAcquisition.Enabled = true;
                    btnSinleShot.Enabled        = true;
                    cmbIPAddresses.Enabled      = false;
                    btnFindDevices.Enabled      = false;
                }
                else
                {
                    MessageBox.Show("Could not connect.", "Connection", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            else
            {
                _analyzer.Stop();
                _connection.Disconnect();
                btnConnect.Text                  = "Connect";
                btnConnect.BackColor             = Color.Gainsboro;
                _analyzer.AcquireState           = AcquireStates.Stopped;
                btnStartAcquisition.Text         = "Stop";
                btnStartAcquisition.BackColor    = Color.Red;
                btnSinleShot.BackColor           = Color.Gainsboro;
                btnStartAcquisition.Enabled      = false;
                _signalGenator.Enabled           = false;
                chkEnableSignalGenerator.Checked = false;
                chkEnableSignalGenerator.Enabled = false; // Enable checkbox;
                btnSinleShot.Enabled             = false;
                cmbIPAddresses.Enabled           = true;
                btnFindDevices.Enabled           = true;
            }
        }
예제 #11
0
    public void Execute()
    {
        Debug.Log("Build Connection");
        MenuManager menuManager = GetComponentInChildren <MenuManager>(true);

        clientConnection.Connect("127.0.0.1", 3456);
        connectionDispatcher.Start();
        string username = usernameInput.text;
        string password = passwordInput.text;

        connectionDispatcher.SendPackage(new LoginRequest()
        {
            Username = username, Password = password
        });

        Debug.Log("Waiting to receive Login Response Package");
        LoginResponse packageData = connectionDispatcher.WaitForPackage <LoginResponse>().Result; // TODO: automate this

        LogPackageResponse(packageData, packageData.IsValidLogin);
    }
예제 #12
0
        public void ConnectToServer(string ip, int port, string username)
        {
            if (Connection.Connected)
            {
                throw new InvalidOperationException("Already connected to a server!");
            }
            Connection.Connect(ip, port);

            PacketRequestConnect pRequestConnect = new PacketRequestConnect(username);

            Connection.SendPacket(pRequestConnect);

            Interface       = new DreamInterface();
            SoundEngine     = new NAudioSoundEngine();
            ResourceManager = new DreamResourceManager();
            StateManager    = new DreamStateManager();

            IconAppearances = new List <IconAppearance>();
            ATOMs           = new Dictionary <UInt32, ATOM>();
            ScreenObjects   = new List <ATOM>();

            MainWindow.Hide();
            _updateTimer.Start();
        }
예제 #13
0
        static void Main(string[] args)
        {
            Console.WriteLine("Welcome in Console.TicTacToe v.0.1 by Michal Jasiak...\r\n");
            Console.WriteLine("Please give your name...");
            var name = Console.ReadLine();

            Console.WriteLine(string.Format("Hello {0},\r\ndo you want X or O?", name));
            var mark = Console.ReadLine();

            Console.WriteLine("Connecting...");

            var connection        = ClientConnection.Connect(_listeningAddress, _listeningPort);
            var connectionHandler = new ClientConnectionHandler(connection);

            connectionHandler.OnMessageReceived += connectionHandler_OnMessageReceived;
            var requestMessage = new RequestMessage
            {
                Data = JsonConvert.SerializeObject(new Player
                {
                    Name = name,
                    Mark = char.Parse(mark)
                }),
                Method = "player/add"
            };

            connectionHandler.Send(JsonConvert.SerializeObject(requestMessage));
            connectionHandler.StartListening();

            string message = string.Empty;

            message = Console.ReadLine();
            while (!message.Equals("exit"))
            {
                var choose = message.Split(' ')[0];
                switch (choose)
                {
                case "newgame":
                {
                    requestMessage = new RequestMessage
                    {
                        Data   = string.Empty,
                        Method = "game/start"
                    };
                    connectionHandler.Send(requestMessage.Serialize());
                    break;
                }

                case "continue":
                {
                    if (_currentGame != null)
                    {
                        Console.Clear();
                        BuildMap(_currentGame.Map);
                        IsYourTurn();
                    }
                    else
                    {
                        Console.WriteLine("You haven't started game yet. Write 'newgame' to start it.");
                    }
                    break;
                }

                case "move":
                {
                    var isNumeric = int.TryParse(message.Split(' ')[1], out int destination);
                    if (isNumeric)
                    {
                        bool isNumber1to9 = Enumerable.Range(1, 9).Contains(destination);
                        if (isNumber1to9)
                        {
                            Move move = new Move
                            {
                                GameId      = _currentGame.Id,
                                Player      = _currentPlayer,
                                Destination = destination - 1
                            };
                            requestMessage = new RequestMessage
                            {
                                Data   = JsonConvert.SerializeObject(move),
                                Method = "game/move"
                            };
                            connectionHandler.Send(requestMessage.Serialize());
                            break;
                        }
                    }
                    Console.WriteLine("First parameter of 'move' should be number from 1-9");
                    break;
                }

                case "help":
                {
                    Console.Clear();
                    Console.WriteLine("--- TicTacToe Help Menu ---");
                    Console.WriteLine("  - newgame | Starts new game.");
                    if (_currentGame != null)
                    {
                        Console.WriteLine("  - continue | Continue game.");
                        Console.WriteLine("  - move field_number | Set your mark on specified field.");
                    }
                    Console.WriteLine("  - help    | Shows help menu");
                    Console.WriteLine("  - exit    | Close game.");
                    break;
                }

                default:
                {
                    Console.WriteLine("Command doesn't exist");
                    break;
                }
                }
                message = Console.ReadLine();
            }

            connectionHandler.Close();
            Console.WriteLine("* Client has exited... *");
            Console.Clear();
        }
예제 #14
0
 public bool OpenConnection()
 {
     try
     {
         client = new ClientConnection(ip, port);
         client.dataReceived += client_dataReceived;
         client.Connect();
     }
     catch (Exception)
     {
     }
     return client.Connected;
 }
예제 #15
0
        public void TryReconnecting()
        {
            if (disposed)
            {
                return;
            }

            var webRequest = WebRequest.Create(queueEndpointSubscriptionPort);

            connectToServerTask = Task.Factory.FromAsync <WebResponse>(webRequest.BeginGetResponse, webRequest.EndGetResponse, null)
                                  .ContinueWith(getPortResponseTask =>
            {
                using (var response = getPortResponseTask.Result)
                    using (var stream = response.GetResponseStream())
                        using (var reader = new StreamReader(stream))
                        {
                            var result = JObject.Load(new JsonTextReader(reader));
                            return(result.Value <int>("SubscriptionPort"));
                        }
            })
                                  .ContinueWith(getPortTask =>
            {
                var result = getPortTask.Result;

                var hostAddresses = Dns.GetHostAddresses(queueEndpointSubscriptionPort.DnsSafeHost);

                return(new IPEndPoint(hostAddresses.First(x => x.AddressFamily == AddressFamily.InterNetwork), result));
            })
                                  .ContinueWith(subscriptionEndpointTask =>
            {
                clientConnection = new ClientConnection(subscriptionEndpointTask.Result, this);

                return(clientConnection.Connect());
            })
                                  .Unwrap()
                                  .ContinueWith(task =>
            {
                if (task.Exception != null)
                {
                    return(task);
                }

                return(clientConnection.Send(JObject.FromObject(new ChangeSubscriptionMessage
                {
                    Type = ChangeSubscriptionType.Set,
                    Queues = new List <string>(lastEtagPerQeueue.Keys)
                })));
            })
                                  .Unwrap()
                                  .ContinueWith(task =>
            {
                if (task.Exception != null)                         // retrying if we got an error
                {
                    if (disposed)
                    {
                        return(task);
                    }

                    Console.WriteLine("Failure {0}", DateTime.Now);
                    GC.Collect(2);
                    GC.WaitForPendingFinalizers();

                    TaskEx.Delay(TimeSpan.FromSeconds(3))
                    .ContinueWith(_ => TryReconnecting());
                    return(task);
                }
                Console.WriteLine("Success");
                // ask for latest
                return(UpdateAsync());
            })
                                  .Unwrap()
                                  .IgnoreExceptions();
        }
예제 #16
0
        static void Main(string[] args)
        {
            Thread.Sleep(2000);
            Console.Write("Connecting to ChannelListener...");

            ClientConnection client = new ClientConnection(new PlainEnvelope(), new SocketTransport());

            //TcpClient client = new TcpClient();
            //client.Connect("localhost", port);
            client.ClientClosed    += new EventHandler <DisconnectedArgs>(client_ClientClosed);
            client.MessageReceived += new EventHandler <MessageEventArgs>(client_MessageReceived);

            client.Connect("localhost", port);

            Console.WriteLine("connected!");

            DateTime connectTime = DateTime.Now;

            Console.WriteLine(string.Format("Connected at {0}", connectTime));

            int count = 1;

            while (true)
            {
                Dictionary <string, string> headers = new Dictionary <string, string>();
                string command = "";

                while (true)
                {
                    command = Console.ReadLine();
                    headers.Clear();

                    while (true)
                    {
                        string line = Console.ReadLine();

                        // check for termination
                        if (line.Length == 0)
                        {
                            break;
                        }

                        string[] pieces = line.Split(':');
                        headers.Add(pieces[0].ToUpper(), pieces[1].ToUpper());
                    }

                    break;
                }

                MessageOne msg = new MessageOne();
                msg.MessageID = "MessageOne";
                msg.Value     = 23;

                //scm.ControlMode = ControlMode.ChannelController;

                try
                {
                    var env = client.Envelope;
                    using (StreamWrapper wrapper = new StreamWrapper(client.Transport.Stream))
                    {
                        env.Serialize(msg, wrapper);
                        //((SocketTransport)client.Transport)
                        //IMessage response = client.Send<Message>(msg);
                        //Console.WriteLine(msg.Name);
                    }
                }
                catch (Exception pex)
                {
                    Console.WriteLine(pex.Message);
                }

                //CustomMessage message = new CustomMessage(command);
                //foreach (string key in headers.Keys)
                //    message.AddKeyValue(key, headers[key]);

                //Message response;
                //{
                //    try
                //    {
                //        response = client.SendAndReceive(message);
                //        Console.WriteLine("Message received: " + response.Name);
                //        Console.WriteLine(response.ToString());
                //    }
                //    catch (Exception ex)
                //    {
                //        Console.WriteLine(ex.Message + "\r\n");
                //        Console.WriteLine("Reconnecting...");
                //        Console.WriteLine(client.Connect());
                //        connectTime = DateTime.Now;
                //        Console.WriteLine(string.Format("Connected at {0}", connectTime));
                //    }
                //}

                TimeSpan ts = DateTime.Now - connectTime;
                Console.WriteLine(string.Format("  connection open for {0:D2}:{1:D2}:{2:D2} [{3} messages processed]\r\n", ts.Hours, ts.Minutes, ts.Seconds, count++));
            }
        }
예제 #17
0
        public E <string> InitializeBot()
        {
            Log.Info("Bot ({0}) connecting to \"{1}\"", Id, config.Connect.Address);

            // Registering config changes
            config.CommandMatcher.Changed += (s, e) =>
            {
                var newMatcher = Filter.GetFilterByName(e.NewValue);
                if (newMatcher.Ok)
                {
                    Filter.Current = newMatcher.Value;
                }
            };
            config.Language.Changed += (s, e) =>
            {
                var langResult = LocalizationManager.LoadLanguage(e.NewValue);
                if (!langResult.Ok)
                {
                    Log.Error("Failed to load language file ({0})", langResult.Error);
                }
            };

            Injector.RegisterType <Bot>();
            Injector.RegisterType <ConfBot>();
            Injector.RegisterType <BotInjector>();
            Injector.RegisterType <PlaylistManager>();
            Injector.RegisterType <Ts3Client>();
            Injector.RegisterType <SessionManager>();
            Injector.RegisterType <HistoryManager>();
            Injector.RegisterType <PlayManager>();
            Injector.RegisterType <IPlayerConnection>();
            Injector.RegisterType <IVoiceTarget>();
            Injector.RegisterType <Ts3BaseFunctions>();
            Injector.RegisterType <Filter>();

            Injector.RegisterModule(this);
            Injector.RegisterModule(config);
            Injector.RegisterModule(Injector);
            Injector.RegisterModule(new PlaylistManager(config.Playlists));
            var teamspeakClient = new Ts3Client(config);

            Injector.RegisterModule(teamspeakClient);
            Injector.RegisterModule(teamspeakClient.TsFullClient);
            Injector.RegisterModule(new SessionManager());
            HistoryManager historyManager = null;

            if (config.History.Enabled)
            {
                Injector.RegisterModule(historyManager = new HistoryManager(config.History), x => x.Initialize());
            }
            Injector.RegisterModule(new PlayManager());
            Injector.RegisterModule(teamspeakClient.TargetPipe);

            var filter = Filter.GetFilterByName(config.CommandMatcher);

            Injector.RegisterModule(new Filter {
                Current = filter.OkOr(Filter.DefaultAlgorithm)
            });
            if (!filter.Ok)
            {
                Log.Warn("Unknown command_matcher config. Using default.");
            }

            if (!Injector.AllResolved())
            {
                Log.Warn("Cyclic bot module dependency");
                Injector.ForceCyclicResolve();
                if (!Injector.AllResolved())
                {
                    Log.Error("Missing bot module dependency");
                    return("Could not load all bot modules");
                }
            }

            PlayerConnection.OnSongEnd        += PlayManager.SongStoppedHook;
            PlayManager.BeforeResourceStarted += BeforeResourceStarted;
            // In own favor update the own status text to the current song title
            PlayManager.AfterResourceStarted += LoggedUpdateBotStatus;
            PlayManager.AfterResourceStopped += LoggedUpdateBotStatus;
            // Log our resource in the history
            if (historyManager != null)
            {
                PlayManager.AfterResourceStarted += (s, e) => historyManager.LogAudioResource(new HistorySaveData(e.PlayResource.BaseData, e.Invoker.ClientUid));
            }
            // Update our thumbnail
            PlayManager.AfterResourceStarted += GenerateStatusImage;
            PlayManager.AfterResourceStopped += GenerateStatusImage;
            // Register callback for all messages happening
            ClientConnection.OnMessageReceived += TextCallback;
            // Register callback to remove open private sessions, when user disconnects
            ClientConnection.OnClientDisconnect += OnClientDisconnect;
            ClientConnection.OnBotConnected     += OnBotConnected;
            ClientConnection.OnBotDisconnect    += OnBotDisconnect;
            BadgesString = config.Connect.Badges;

            // Connect the query after everyting is set up
            return(ClientConnection.Connect());
        }