void IDriverPresenter.OnRegisterDriver() { try { DriverClient listener = new DriverClient(this); _scsClient = ScsServiceClientBuilder.CreateClient <IDriverServer>( new ScsTcpEndPoint(defaultIP, defaultPort), listener); _scsClient.Connect(); _server = _scsClient.ServiceProxy; _driverId = _view.GetDriverId(); if (_driverId != INVALID_DRIVER_ID) { _server.RegisterDriver(_driverId, 0); _view.OnConnected(); } else { _scsClient = null; _view.OnDisconnected(); } } catch (Exception) { _scsClient = null; _view.OnDisconnected(); } }
private void Connect(object sender, RoutedEventArgs e) { if (ScsClient != null) ScsClient.Disconnect(); ScsClient = ScsServiceClientBuilder.CreateClient<IInformerService>( new ScsTcpEndPoint(ServerIp.Text, 23232), Client); ScsClient.Timeout = 1000; ScsClient.ConnectTimeout = 2000; ScsClient.Connected += OnScsConnnected; ScsClient.Disconnected += OnScsDisconnected; Log("Try connect..."); ThreadPool.QueueUserWorkItem( o => { try { ScsClient.Connect(); } catch { Log("Can't connect to server."); } }); }
void IDriverPresenter.RegisterDriver(int driverID) { try { _driverId = driverID; DriverClient listener = new DriverClient(this); _scsClient = ScsServiceClientBuilder.CreateClient <IDriverServer>( new ScsTcpEndPoint(defaultIP, defaultPort), listener); _scsClient.Connect(); _server = _scsClient.ServiceProxy; if (_driverId != INVALID_DRIVER_ID && _server.RegisterDriver(_driverId, 0) == 0) { NotifyConnected(); } else { _scsClient = null; NotifyDisconnected(); } } catch (Exception) { _scsClient = null; NotifyDisconnected(); } }
private void Connect(object sender, RoutedEventArgs e) { if (ScsClient != null) { ScsClient.Disconnect(); } ScsClient = ScsServiceClientBuilder.CreateClient <IInformerService>( new ScsTcpEndPoint(ServerIp.Text, 23232), Client); ScsClient.Timeout = 1000; ScsClient.ConnectTimeout = 2000; ScsClient.Connected += OnScsConnnected; ScsClient.Disconnected += OnScsDisconnected; Log("Try connect..."); ThreadPool.QueueUserWorkItem( o => { try { ScsClient.Connect(); } catch { Log("Can't connect to server."); } }); }
public void ConnectionTest() { //Disconnect if currently connected //Create a ChatClient to handle remote method invocations by server //_chatClient = this; //Create a SCS client to connect to SCS server //The 2nd parameter is EXTREMELY important to note and must be non-null if you want to have Server -> Client callbacks. _scsClient = ScsServiceClientBuilder.CreateClient<IChatService>( new ScsTcpEndPoint("127.0.0.1", 10048), this ); //Register events of SCS client _scsClient.Connected += ScsClient_Connected; _scsClient.Disconnected += ScsClient_Disconnected; //Connect to the server _scsClient.Connect(); Thread.Sleep(5000); _scsClient.ServiceProxy.SendMessageToRoom(new ChatMessage("Hi Everyone")); Console.ReadKey(); }
public void Connect() { _client = ScsServiceClientBuilder.CreateClient<INDistManagementService>(ScsEndPoint.CreateEndPoint(Address), _serverListener); _client.Connected += Client_Connected; _client.Disconnected += Client_Disconnected; _client.Connect(); }
public void Connect() { _client = ScsServiceClientBuilder.CreateClient <INDistManagementService>(ScsEndPoint.CreateEndPoint(Address), _serverListener); _client.Connected += Client_Connected; _client.Disconnected += Client_Disconnected; _client.Connect(); }
public bool Connect(string IP, int Port) { clientService = ScsServiceClientBuilder.CreateClient <ITaxiService>(new ScsTcpEndPoint(IP, Port)); try { clientService.Connect(); } catch { clientService.Dispose(); return(false); } return(true); }
public void GetExamCopy() { // try { HighSecurity = highSecChkBox.Checked; //Create a client to connecto to phone book service on local server and //10048 TCP port. client = ScsServiceClientBuilder.CreateClient <INetworkExamService>( new ScsTcpEndPoint(ipTxtBox.Text, int.Parse(portTxtBox.Text))); // client.Timeout = 3; aLogger.LogMessage($"Trying to connect to the server (timeout {client.Timeout} Seconds)", LogMsgType.Verbose); //Connect to the server client.Connect(); aLogger.LogMessage("Connected to server", LogMsgType.Verbose); RequiredDetails requiredDetails = new RequiredDetails(studentNameTxtBox.Text, studentIDTxtBox.Text, examKeyTxtBox.Text, (HighSecurity? sharedKeyISTxtBox.Text:"Low Security Settings Selected")); //Add some persons var copy = client.ServiceProxy.GetExamCopyEncryptedZipped(requiredDetails); requiredDetails.DecryptDetails(examKeyTxtBox.Text); if (!ExamHelper.ValidateExamCopy(copy, examKeyTxtBox.Text, aLogger, sharedKeyISTxtBox.Text, (highSecChkBox.Checked ? Security.FilterationSecurityLevel.High : Security.FilterationSecurityLevel.Moderate), requiredDetails.SequenceNumber)) { return; } aLogger.LogMessage("Received Exam Copy", LogMsgType.Verbose); aLogger.LogMessage("Checking Exam Copy...", LogMsgType.Verbose); var exam = Quizez.ExamHelper.GetExamFromByteArray(copy, examKeyTxtBox.Text, sharedKeyISTxtBox.Text, (highSecChkBox.Checked?Security.FilterationSecurityLevel.High:Security.FilterationSecurityLevel.Moderate)); aLogger.LogMessage("Exam Checked Correcly ...", LogMsgType.Verbose); //Disconnect from server // client.Disconnect(); // aLogger.LogMessage("Disconnected from server", LogMsgType.Verbose); anExam = exam; } // catch (Exception ex) { // aLogger.LogMessage(ex.Message, LogMsgType.Error); } }
public void Connect(string serverAddress, int serverPort) { Trace.WriteLine(Invariant($"Connecting to {serverAddress}")); try { HsClient = ScsServiceClientBuilder.CreateClient <IHSApplication>(new ScsTcpEndPoint(serverAddress, serverPort), this); HsClient.Connect(); HS = HsClient.ServiceProxy; #pragma warning disable S1481 // Unused local variables should be removed var apiVersion = HS.APIVersion; // just to make sure our connection is valid #pragma warning restore S1481 // Unused local variables should be removed hsTraceListener = new HSTraceListener(this as ILogger); Debug.Listeners.Add(hsTraceListener); } catch (Exception ex) { throw new HspiConnectionException(Invariant($"Error connecting homeseer SCS client: {ex.GetFullMessage()}"), ex); } try { CallbackClient = ScsServiceClientBuilder.CreateClient <IAppCallbackAPI>(new ScsTcpEndPoint(serverAddress, serverPort), this); CallbackClient.Connect(); Callback = CallbackClient.ServiceProxy; #pragma warning disable S1481 // Unused local variables should be removed var apiVersion = Callback.APIVersion; // just to make sure our connection is valid #pragma warning restore S1481 // Unused local variables should be removed } catch (Exception ex) { throw new HspiConnectionException(Invariant($"Error connecting callback SCS client: {ex.GetFullMessage()}"), ex); } // Establish the reverse connection from homeseer back to our plugin try { HS.Connect(Name, InstanceFriendlyName()); } catch (Exception ex) { throw new HspiConnectionException(Invariant($"Error connecting homeseer to our plugin: {ex.GetFullMessage()}"), ex); } HsClient.Disconnected += HsClient_Disconnected; Trace.WriteLine(Invariant($"Connected to {serverAddress}")); }
public void Connect(string serverAddress, int serverPort) { // This method is called by our console wrapper at launch time // Create our main connection to the homeseer TCP communication framework // part 1 - hs object Proxy try { HsClient = ScsServiceClientBuilder.CreateClient <IHSApplication>(new ScsTcpEndPoint(serverAddress, serverPort), this); HsClient.Connect(); Hs = HsClient.ServiceProxy; // ReSharper disable once UnusedVariable var apiVersion = Hs.APIVersion; // just to make sure our connection is valid } catch (Exception ex) { throw new Exception("Error connecting homeseer SCS client: " + ex.Message, ex); } // part 2 - callback object Proxy try { CallbackClient = ScsServiceClientBuilder.CreateClient <IAppCallbackAPI>( new ScsTcpEndPoint(serverAddress, serverPort), this); CallbackClient.Connect(); Callback = CallbackClient.ServiceProxy; // ReSharper disable once UnusedVariable var apiVersion = Callback.APIVersion; // just to make sure our connection is valid } catch (Exception ex) { throw new Exception("Error connecting callback SCS client: " + ex.Message, ex); } // Establish the reverse connection from homeseer back to our plugin try { Hs.Connect(Name, InstanceFriendlyName()); } catch (Exception ex) { throw new Exception("Error connecting homeseer to our plugin: " + ex.Message, ex); } }
private void loginButton_Click(object sender, EventArgs e) { client = ScsServiceClientBuilder.CreateClient <IBugTrackerService>(new ScsTcpEndPoint("127.0.0.1", 10048)); client.Connect(); userInfo = new UserInfo(); userInfo.Username = usernameField.Text; userInfo.Password = passwordField.Text; if (client.ServiceProxy.Login(userInfo)) { this.DialogResult = DialogResult.OK; this.Close(); } else { MessageBox.Show("Wrong username or password"); } }
static void Main() { ServerOpt so = new ServerOpt(); Client = new InformerClient(); Client.OnMessage += Console.WriteLine; Client.OnAuthed += () => { Console.WriteLine("Authed..."); new Thread(SendOnlineUpdates).Start(); }; ScsClient = ScsServiceClientBuilder.CreateClient <IInformerService> (new ScsTcpEndPoint(so.serverip, so.informerPort), Client); ScsClient.Timeout = ScsClient.ConnectTimeout = 2500; ScsClient.Connected += (sender, args) => { Console.WriteLine("Connected..."); ScsClient.ServiceProxy.Auth(so.sercurityKey); }; while (true) { try { if (ScsClient.CommunicationState == CommunicationStates.Disconnected) { ScsClient.Connect(); } while (ScsClient.CommunicationState == CommunicationStates.Connected) { Thread.Sleep(1000); } } catch { } SendUpdate(); //Offline } }
/// <summary> /// Connects to the server. /// It automatically Logins to server if connection success. /// </summary> public void Connect() { //Disconnect if currently connected Disconnect(); //Create a ChatClient to handle remote method invocations by server _bugTrackerClient = new BugTrackerClient(BugProcess); //Create a SCS client to connect to SCS server _scsClient = ScsServiceClientBuilder.CreateClient <IBugTrackerService>(new ScsTcpEndPoint("localhost", 10048), _bugTrackerClient); //Register events of SCS client _scsClient.Connected += ScsClient_Connected; _scsClient.Disconnected += ScsClient_Disconnected; //Connect to the server _scsClient.Connect(); }
/// <summary> /// Connects to the server. /// It automatically Logins to server if connection success. /// </summary> public void Connect() { //Disconnect if currently connected Disconnect(); //Create a ChatClient to handle remote method invocations by server _chatClient = new ChatClient(ChatRoom); //Create a SCS client to connect to SCS server _scsClient = ScsServiceClientBuilder.CreateClient <IChatService>(new ScsTcpEndPoint(LoginForm.ServerIpAddress, LoginForm.ServerTcpPort), _chatClient); //Register events of SCS client _scsClient.Connected += ScsClient_Connected; _scsClient.Disconnected += ScsClient_Disconnected; //Connect to the server _scsClient.Connect(); }
/// <summary> /// Connects to the server. /// It automatically Logins to server if connection success. /// </summary> public void Connect() { //Disconnect if currently connected Disconnect(); //Create a ChatClient to handle remote method invocations by server _chatClient = new ChatClient(ChatRoom); //Create a SCS client to connect to SCS server _scsClient = ScsServiceClientBuilder.CreateClient<IChatService>(new ScsTcpEndPoint(LoginForm.ServerIpAddress, LoginForm.ServerTcpPort), _chatClient); //Register events of SCS client _scsClient.Connected += ScsClient_Connected; _scsClient.Disconnected += ScsClient_Disconnected; //Connect to the server _scsClient.Connect(); }
private void Connect(int attempts) { try { _client.Connect(); SpeechHost = _client.ServiceProxy; //make sure the interface is supported try { var speakHostVersion = SpeechHost.version(); if (speakHostVersion != SPEAKER_INTERFACE_VERSION) { Console.WriteLine("Speaker API version mismatch"); DisconnectNow(); return; } } catch (Exception exception) { Console.WriteLine($"Error attempting to connect to server, please check your connection options: {exception.Message}"); DisconnectNow(); return; } var response = SpeechHost.Connect(HostName, ClientName, IpAddress, _username, _password); if (string.IsNullOrEmpty(response)) { return; } Console.WriteLine($"Error, Unable to connect speaker client interface: {response}"); DisconnectNow(); } catch (Exception exception) { Console.WriteLine($"Cannot connect speaker client attempt {attempts.ToString()}"); if (exception.Message.ToLower().Contains("timeout occurred.") && attempts < 6) { Connect(attempts + 1); } else { DisconnectNow(); Console.WriteLine($"Error, Unable to connect speaker client interface: {exception.Message}"); } } }
/// <summary> /// Connects to the server. /// It automatically Logins to server if connection success. /// </summary> public void Connect() { //Disconnect if currently connected Disconnect(); //Create a ChatClient to handle remote method invocations by server _chatClient = new ChatClient(FormView); //Create a SCS client to connect to SCS server _scsClient = ScsServiceClientBuilder.CreateClient <IMsgService>(new ScsTcpEndPoint("127.0.0.1", 9000), _chatClient); //Register events of SCS client _scsClient.Connected += ScsClient_Connected; _scsClient.Disconnected += ScsClient_Disconnected; //Connect to the server _scsClient.Connect(); }
static void Main() { ServerOpt so = new ServerOpt(); Client = new InformerClient(); Client.OnMessage += Console.WriteLine; Client.OnAuthed += () => { Console.WriteLine("Authed..."); new Thread(SendOnlineUpdates).Start(); }; ScsClient = ScsServiceClientBuilder.CreateClient<IInformerService> (new ScsTcpEndPoint(so.serverip, so.informerPort), Client); ScsClient.Timeout = ScsClient.ConnectTimeout = 2500; ScsClient.Connected += (sender, args) => { Console.WriteLine("Connected..."); ScsClient.ServiceProxy.Auth(so.sercurityKey); }; while (true) { try { if (ScsClient.CommunicationState == CommunicationStates.Disconnected) ScsClient.Connect(); while (ScsClient.CommunicationState == CommunicationStates.Connected) Thread.Sleep(1000); } catch { } SendUpdate(); //Offline } }
public AuthentificationServiceClient() { string ip = ConfigurationManager.AppSettings["MasterIP"]; int port = Convert.ToInt32(ConfigurationManager.AppSettings["MasterPort"]); _client = ScsServiceClientBuilder.CreateClient <IAuthentificationService>(new ScsTcpEndPoint(ip, port)); System.Threading.Thread.Sleep(1000); while (_client.CommunicationState != CommunicationStates.Connected) { try { _client.Connect(); } catch (Exception) { Logger.Error(Language.Instance.GetMessageFromKey("RETRY_CONNECTION"), memberName: nameof(AuthentificationServiceClient)); System.Threading.Thread.Sleep(1000); } } }
public CommunicationServiceClient() { string ip = ConfigurationManager.AppSettings["MasterIP"]; int port = Convert.ToInt32(ConfigurationManager.AppSettings["MasterPort"]); _commClient = new CommunicationClient(); _client = ScsServiceClientBuilder.CreateClient <ICommunicationService>(new ScsTcpEndPoint(ip, port), _commClient); while (_client.CommunicationState != CommunicationStates.Connected) { try { _client.Connect(); } catch { Logger.Log.Error(Language.Instance.GetMessageFromKey("RETRY_CONNECTION")); System.Threading.Thread.Sleep(5000); } } }
public void Connect(string serverAddress, int serverPort) { hsClient = ScsServiceClientBuilder.CreateClient <IHSApplication>( new ScsTcpEndPoint(serverAddress, serverPort), this); hsClient.Connect(); hs = hsClient.ServiceProxy; Program.HsClient = hs; // make sure we're connected successfully double apiVersion = hs.APIVersion; callbackClient = ScsServiceClientBuilder.CreateClient <IAppCallbackAPI>(new ScsTcpEndPoint(serverAddress, serverPort), this); callbackClient.Connect(); callbacks = callbackClient.ServiceProxy; apiVersion = callbacks.APIVersion; hs.Connect(this.Name, this.InstanceFriendlyName()); }
public AuthentificationServiceClient() { string ip = ConfigurationManager.AppSettings["MasterIP"]; int port = Convert.ToInt32(ConfigurationManager.AppSettings["MasterPort"]); _client = ScsServiceClientBuilder.CreateClient <IAuthentificationService>(new ScsTcpEndPoint(ip, port)); System.Threading.Thread.Sleep(1000); while (_client.CommunicationState != CommunicationStates.Connected) { try { _client.Connect(); } catch (Exception) { Console.ForegroundColor = ConsoleColor.Yellow; Console.WriteLine("[Info] Connection will be established"); System.Threading.Thread.Sleep(1000); } } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// <summary> /// Connects to Homeseer at the specified server address and port. /// This is called by the console wrapper. /// </summary> /// <param name="serverAddress">The server address.</param> /// <param name="serverPort">The server port.</param> /// <exception cref="Exception"> Error connecting homeseer SCS client </exception> /// <exception cref="Exception"> Error connecting callback SCS client </exception> /// <exception cref="Exception"> Error connecting homeseer to our plugin </exception> public virtual void Connect(string serverAddress, int serverPort) { // Create our main connection to the homeseer TCP communication framework // part 1 - hs object Proxy try { hsClient = ScsServiceClientBuilder.CreateClient <IHSApplication>(new ScsTcpEndPoint(serverAddress, serverPort), this); hsClient.Connect(); hs = hsClient.ServiceProxy; double APIVersion = hs.APIVersion; // just to make sure our connection is valid } catch (Exception ex) { throw new Exception("Error connecting homeseer SCS client: " + ex.Message, ex); } // part 2 - callback object Proxy try { callbackClient = ScsServiceClientBuilder.CreateClient <IAppCallbackAPI>(new ScsTcpEndPoint(serverAddress, serverPort), this); callbackClient.Connect(); callback = callbackClient.ServiceProxy; double APIVersion = callback.APIVersion; // just to make sure our connection is valid } catch (Exception ex) { throw new Exception("Error connecting callback SCS client: " + ex.Message, ex); } // Establish the reverse connection from homeseer back to our plugin try { hs.Connect(IFACE_NAME, INSTANCE_NAME); } catch (Exception ex) { throw new Exception("Error connecting homeseer to our plugin: " + ex.Message, ex); } }
private void TryToConnect() { while (LoginBridge.CommunicationState != CommunicationStates.Connected && _autoConnect) { Log.Info("Try to connect to Login Server at {0}:{1}", _loginIp, _loginPort); try { LoginBridge.Connect(); Log.Info("Connected to Login Server at {0}:{1}", _loginIp, _loginPort); } catch { if (LoginBridge == null) { return; } Log.Info("Connection failed, reconnect..."); ConnectToLogin(); } } }
private void Button_Click(object sender, RoutedEventArgs e) { if (LoginBox.Text == "" || PasswordBox.Password == "") { MessageBox.Show("Incorrect login or password"); return; } try { LauncherService = ScsServiceClientBuilder.CreateClient <ILauncherContract>( new ScsTcpEndPoint("127.0.0.1", 6667)); LauncherService.ConnectTimeout = 3000; LauncherService.Timeout = 1000; LauncherService.Connect(); StartingSequence(LauncherService.ServiceProxy.RegisterClientToken(LoginBox.Text, PasswordBox.Password)); if (RememberBox.IsChecked != null && RememberBox.IsChecked.Value) { using (StreamWriter sw = new StreamWriter(".\\cfg.ini")) { sw.WriteLine("{0}@{1}", LoginBox.Text, PasswordBox.Password); } } } catch (Exception ex) { MessageBox.Show(ex.ToString()); } finally { Close(); } }
public void run() { string[] cmdArgs = Environment.GetCommandLineArgs(); Console.WriteLine("Manager::run() - arguments are {0}", Environment.CommandLine); String paramServer = "127.0.0.1"; String paramInstance = ""; foreach (string arg in cmdArgs) { Console.WriteLine(" - arg: {0}", arg); if (arg.Contains("=")) { String[] ArgS = arg.Split('='); Console.WriteLine(" -- {0}=>{1}", ArgS[0], ArgS[1]); switch (ArgS[0]) { case "server": paramServer = ArgS[1]; break; case "instance": paramInstance = ArgS[1]; break; default: Console.WriteLine("Unhandled param: {0}", ArgS[0]); break; } } } pluginInst = new HSPI(paramInstance); //Environment.CommandLine. client = ScsServiceClientBuilder.CreateClient<IHSApplication>(new ScsTcpEndPoint(paramServer, 10400), pluginInst); clientCB = ScsServiceClientBuilder.CreateClient<IAppCallbackAPI>(new ScsTcpEndPoint(paramServer, 10400), pluginInst); try { client.Connect(); clientCB.Connect(); hsHost = client.ServiceProxy; double ApiVer = hsHost.APIVersion; Console.WriteLine("Host ApiVersion : {0}", ApiVer); hsHostCB = clientCB.ServiceProxy; ApiVer = hsHostCB.APIVersion; Console.WriteLine("Host CB ApiVersion : {0}", ApiVer); } catch (Exception e) { Console.WriteLine("Cannot start instance because of : {0}", e.Message); return; } Console.WriteLine("Connection to HS succeeded!"); try { pluginInst.hsHost = hsHost; pluginInst.hsHostCB = hsHostCB; hsHost.Connect(pluginInst.Name, ""); Console.WriteLine("Connected, waiting to be initialized..."); do { Thread.Sleep(500); } while (client.CommunicationState == CommunicationStates.Connected && pluginInst.Running); Console.WriteLine("Connection lost, exiting"); pluginInst.Running = false; client.Disconnect(); clientCB.Disconnect(); } catch (Exception e) { Console.WriteLine("Failed to host connect: {0}", e.Message); return; } Console.WriteLine("Exiting!!!"); }
private void LoginToServer(string username, string password, string host) { _pingTimer.Enabled = false; _client = new DataClientClass(username); _logClient = new DataNetLogService(); _serverHost = host; _logClientService = ScsServiceClientBuilder.CreateClient<IDataNetLogService>(new ScsTcpEndPoint(host, 443), _logClient); _clientService = ScsServiceClientBuilder.CreateClient<IDataAdminService>(new ScsTcpEndPoint(host, 443), _client); _clientService.Connected += ScsClient_Connected; try { _clientService.Connect(); _logClientService.Connect(); _client.login += LoggedIn; _client.block += BlockedByAdmin; _client.loginFailed += LoginFailed; _client.changePrivilages += ChangedPrivileges; _client.logout += DeletedClient; _client.symblolListRecieved += GroupSymbolChange; _client.symbolListChanged += RefreshSymbols; _client.groupChanged += RefreshGroups; _client.logoutServer += ServerStatusChanged; _client.busySymbolListReceived += BusySymbolChanged; _client.symbolPermissionChanged += RefreshSymbols; _clientService.Disconnected += OnServerCrashed; var logmsg = new DataAdminMessageFactory.LogMessage { Symbol = username, LogType = DataAdminMessageFactory.LogMessage.Log.Login, Group = "" }; _logClientService.ServiceProxy.SendSimpleLog(logmsg); Settings.Default.connectionHost = _startControl.ui_textBox_ip.Text; } catch (Exception ex) { Console.WriteLine(ex.Message); if (_startControl != null) _startControl.Invoke((Action)(() => { ToastNotification.Show(_startControl, "Can't connect. IP is incorrect"); _startControl.ui_buttonX_logon.Enabled = true; } )); return; } var loginMsg = new DataAdminMessageFactory.LoginMessage(username, password, 't'); try { _clientService.ServiceProxy.Login(loginMsg); } catch (Exception ex) { Console.WriteLine(ex.Message); MessageBox.Show(ex.Message); } }
private bool LoginToNormalizer(string host) { var serverStatus = true; var succesLogin = true; var tcpClient = new TcpClient(); try { tcpClient.Connect(host, 442); } catch (Exception ex) { ToastNotification.Show(this, "The DataNormalizer is not available."); Console.Write(ex.Message); serverStatus = false; } if (serverStatus) { _dataNormalizatorClient = new DataNormalizatorClient(); _dnormClientService = ScsServiceClientBuilder.CreateClient<IDataNormalizatorService>(new ScsTcpEndPoint(host, 442), _dataNormalizatorClient); try { _dnormClientService.Connect(); _dnormClientService.ServiceProxy.Login(new DataNormalizatorMessageFactory.LoginMessage() { Username = _client.UserName, IsLoginedToDa = true, ServerMessage = "" }); _normalizerStatus = true; } catch (Exception) { succesLogin = false; _normalizerStatus = false; } if (succesLogin) { _dnormClientService.Disconnected += OnDNormCrashed; _dataNormalizatorClient.OnActivation += CollectActivated; _dataNormalizatorClient.OnDeactivation += CollectDeactivated; } } else succesLogin = false; return succesLogin; }
private void OnGetAllIdsButtonClick(Object sender , EventArgs e) { if (m_RemoteAccessClient == null) { m_RemoteAccessClient = ScsServiceClientBuilder.CreateClient <IDVDProfilerRemoteAccess>(new ScsTcpEndPoint(IPAddressTextBox.Text, 10083)); m_RemoteAccessClient.Connect(); } ProfileIdListView.Items.Clear(); TransactionObject transactionObject = m_RemoteAccessClient.ServiceProxy.BeginTransaction(); if (m_ChangeNotificationObject == null) { AccessResult <ChangeNotificationObject> result = m_RemoteAccessClient.ServiceProxy.RegisterForProfileChanges(transactionObject, false); m_ChangeNotificationObject = result.Result; Timer.Interval = 5000; Timer.Tick += new EventHandler(OnTimer1Tick); } Timer.Stop(); try { AccessResult <List <String> > result = m_RemoteAccessClient.ServiceProxy.GetAllProfileIds(transactionObject, false); if (result.Success) { if (result.Result != null) { foreach (String profileId in result.Result) { ListViewItem item = new ListViewItem(); GetTitle(transactionObject, profileId, item); ProfileIdListView.Items.Add(item); } } m_RemoteAccessClient.ServiceProxy.CommitTransaction(transactionObject); } else { m_RemoteAccessClient.ServiceProxy.AbortTransaction(transactionObject); MessageBox.Show("An error occured", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } Timer.Start(); } catch (Exception ex) { try { m_RemoteAccessClient.ServiceProxy.AbortTransaction(transactionObject); } catch { } MessageBox.Show(ex.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } }
public static void Main(string[] args) { string serverIp = "127.0.0.1"; string serverCmd = null; foreach (string serverCmd_loopVariable in args) { serverCmd = serverCmd_loopVariable; string[] ch = new string[1]; ch[0] = "="; string[] parts = serverCmd.Split(ch, StringSplitOptions.None); switch (parts[0].ToLower()) { case "server": serverIp = parts[1]; break; case "instance": try { Util.Instance = parts[1]; } catch (Exception) { Util.Instance = ""; } break; } } Reconnect: Console.WriteLine("Plugin: " + Util.IFACE_NAME + " Instance: " + Util.Instance + " starting..."); Console.WriteLine("Connecting to server at " + serverIp + "..."); client = ScsServiceClientBuilder.CreateClient <IHSApplication>(new ScsTcpEndPoint(serverIp, 10400), plugin); clientCallback = ScsServiceClientBuilder.CreateClient <IAppCallbackAPI>(new ScsTcpEndPoint(serverIp, 10400), plugin); int Attempts = 1; TryAgain: try { client.Connect(); clientCallback.Connect(); double APIVersion = 0; try { host = client.ServiceProxy; APIVersion = host.APIVersion; // will cause an error if not really connected Console.WriteLine("Host API Version: " + APIVersion.ToString()); } catch (Exception ex) { Console.WriteLine("Error getting API version from host object: " + ex.Message + "->" + ex.StackTrace); //Return } try { callback = clientCallback.ServiceProxy; APIVersion = callback.APIVersion; // will cause an error if not really connected } catch (Exception ex) { Console.WriteLine("Error getting API version from callback object: " + ex.Message + "->" + ex.StackTrace); return; } } catch (Exception ex) { Console.WriteLine("Cannot connect attempt " + Attempts.ToString() + ": " + ex.Message); if (ex.Message.ToLower().Contains("timeout occurred.")) { Attempts += 1; if (Attempts < 6) { goto TryAgain; } } if (client != null) { client.Dispose(); client = null; } if (clientCallback != null) { clientCallback.Dispose(); clientCallback = null; } wait(4); return; } try { connectionJunction(); if (reset) { HSPI.armReset(); goto Reconnect; } else { System.Environment.Exit(0); } } catch (Exception ex) { Console.WriteLine("Cannot connect(2): " + ex.Message); wait(2); System.Environment.Exit(0); return; } }
public void run() { string[] cmdArgs = Environment.GetCommandLineArgs(); Console.WriteLine("Manager::run() - arguments are {0}", Environment.CommandLine); String paramServer = "127.0.0.1"; String paramInstance = ""; foreach (string arg in cmdArgs) { Console.WriteLine(" - arg: {0}", arg); if (arg.Contains("=")) { String[] ArgS = arg.Split('='); Console.WriteLine(" -- {0}=>{1}", ArgS[0], ArgS[1]); switch (ArgS[0]) { case "server": paramServer = ArgS[1]; break; case "instance": paramInstance = ArgS[1]; break; default: Console.WriteLine("Unhandled param: {0}", ArgS[0]); break; } } } pluginInst = new HSPI(paramInstance); //Environment.CommandLine. client = ScsServiceClientBuilder.CreateClient <IHSApplication>(new ScsTcpEndPoint(paramServer, 10400), pluginInst); clientCB = ScsServiceClientBuilder.CreateClient <IAppCallbackAPI>(new ScsTcpEndPoint(paramServer, 10400), pluginInst); try { client.Connect(); clientCB.Connect(); hsHost = client.ServiceProxy; double ApiVer = hsHost.APIVersion; Console.WriteLine("Host ApiVersion : {0}", ApiVer); hsHostCB = clientCB.ServiceProxy; ApiVer = hsHostCB.APIVersion; Console.WriteLine("Host CB ApiVersion : {0}", ApiVer); } catch (Exception e) { Console.WriteLine("Cannot start instance because of : {0}", e.Message); return; } Console.WriteLine("Connection to HS succeeded!"); try { pluginInst.hsHost = hsHost; pluginInst.hsHostCB = hsHostCB; hsHost.Connect(pluginInst.Name, ""); Console.WriteLine("Connected, waiting to be initialized..."); do { Thread.Sleep(500); } while (client.CommunicationState == CommunicationStates.Connected && pluginInst.Running); Console.WriteLine("Connection lost, exiting"); pluginInst.Running = false; client.Disconnect(); clientCB.Disconnect(); } catch (Exception e) { Console.WriteLine("Failed to host connect: {0}", e.Message); return; } Console.WriteLine("Exiting!!!"); }
private void Button_Click(object sender, RoutedEventArgs e) { if (LoginBox.Text == "" || PasswordBox.Password == "") { MessageBox.Show("Incorrect login or password"); return; } try { LauncherService = ScsServiceClientBuilder.CreateClient<ILauncherContract>( new ScsTcpEndPoint("127.0.0.1", 6667)); LauncherService.ConnectTimeout = 3000; LauncherService.Timeout = 1000; LauncherService.Connect(); StartingSequence(LauncherService.ServiceProxy.RegisterClientToken(LoginBox.Text, PasswordBox.Password)); if (RememberBox.IsChecked != null && RememberBox.IsChecked.Value) { using (StreamWriter sw = new StreamWriter(".\\cfg.ini")) { sw.WriteLine("{0}@{1}", LoginBox.Text, PasswordBox.Password); } } } catch (Exception ex) { MessageBox.Show(ex.ToString()); } finally { Close(); } }
private void LoginToServer(string username, string password, string host, bool isMaster) { _logonThread = new Thread( () => { _pingTimer.Enabled = false; _client = new DataClientClass(username); _logClient = new DataNetLogService(); _logClientService = ScsServiceClientBuilder.CreateClient<IDataNetLogService>(new ScsTcpEndPoint(host, 443), _logClient); _clientService = ScsServiceClientBuilder.CreateClient<IDataAdminService>(new ScsTcpEndPoint(host, 443), _client); _clientService.Connected += ScsClient_Connected; try { _clientService.Connect(); _logClientService.Connect(); _client.login += LoggedIn; _client.block += BlockedByAdmin; _client.loginFailed += LoginFailed; _client.changePrivilages += ChangedPrivileges; _client.logout += DeletedClient; _client.symblolListRecieved += GroupSymbolChange; _client.symbolListChanged += RefreshSymbols; _client.groupChanged += RefreshGroups; //_client.logoutServer += ServerStatusChanged; _client.busySymbolListReceived += BusySymbolChanged; _client.symbolPermissionChanged += RefreshSymbols; _clientService.Disconnected += OnServerCrashed; var logmsg = new DataAdminMessageFactory.LogMessage { Symbol = username, LogType = DataAdminMessageFactory.LogMessage.Log.Login, Group = "" }; _logClientService.ServiceProxy.SendSimpleLog(logmsg); Settings.Default.scHost = _startControl.ui_textBox_ip.Text; Settings.Default.scHostSlave = _startControl.ui_textBox_ip_slave.Text; Invoke((Action) (() => { labelItem_server.Text = isMaster ? "Master" : "Slave"; styleManager1.MetroColorParameters = new MetroColorGeneratorParameters(Color.White, isMaster ? Color.Green : Color.YellowGreen); metroStatusBar1.Refresh(); })); } catch (Exception ex) { Console.WriteLine(ex.Message); if (_startControl != null) _startControl.Invoke((Action) (() => { if (isMaster) { ToastNotification.Show(_startControl, "Can't connect. IP is incorrect"); _startControl.ui_buttonX_logon.Enabled = true; } else { Logout(); } } )); return; } var loginMsg = new DataAdminMessageFactory.LoginMessage(username, password, 'd'); try { _clientService.ServiceProxy.Login(loginMsg); } catch (Exception ex) { Console.WriteLine(ex.Message); MessageBox.Show(ex.Message); } }) {Name = "LogonThread", IsBackground = true}; _logonThread.Start(); }
public static void Main(string[] args) { string serverIp = "127.0.0.1"; string serverCmd = null; foreach (string serverCmd_loopVariable in args) { serverCmd = serverCmd_loopVariable; string[] ch = new string[1]; ch[0] = "="; string[] parts = serverCmd.Split(ch, StringSplitOptions.None); switch (parts[0].ToLower()) { case "server": serverIp = parts[1]; break; case "instance": try { Util.Instance = parts[1]; } catch (Exception) { Util.Instance = ""; } break; } } Console.WriteLine("Plugin: " + Util.IFACE_NAME + " Instance: " + Util.Instance + " starting..."); Console.WriteLine("Connecting to server at " + serverIp + "..."); client = ScsServiceClientBuilder.CreateClient <IHSApplication>(new ScsTcpEndPoint(serverIp, 10400), plugin); clientCallback = ScsServiceClientBuilder.CreateClient <IAppCallbackAPI>(new ScsTcpEndPoint(serverIp, 10400), plugin); int Attempts = 1; TryAgain: try { client.Connect(); clientCallback.Connect(); double APIVersion = 0; try { host = client.ServiceProxy; APIVersion = host.APIVersion; // will cause an error if not really connected Console.WriteLine("Host API Version: " + APIVersion.ToString()); } catch (Exception ex) { Console.WriteLine("Error getting API version from host object: " + ex.Message + "->" + ex.StackTrace); //Return } try { callback = clientCallback.ServiceProxy; APIVersion = callback.APIVersion; // will cause an error if not really connected } catch (Exception ex) { Console.WriteLine("Error getting API version from callback object: " + ex.Message + "->" + ex.StackTrace); return; } } catch (Exception ex) { Console.WriteLine("Cannot connect attempt " + Attempts.ToString() + ": " + ex.Message); if (ex.Message.ToLower().Contains("timeout occurred.")) { Attempts += 1; if (Attempts < 6) { goto TryAgain; } } if (client != null) { client.Dispose(); client = null; } if (clientCallback != null) { clientCallback.Dispose(); clientCallback = null; } wait(4); return; } try { // create the user object that is the real plugin, accessed from the pluginAPI wrapper Util.callback = callback; Util.hs = host; plugin.OurInstanceFriendlyName = Util.Instance; // connect to HS so it can register a callback to us host.Connect(Util.IFACE_NAME, Util.Instance); Console.WriteLine("Connected, waiting to be initialized..."); do { System.Threading.Thread.Sleep(10); } while (client.CommunicationState == HSCF.Communication.Scs.Communication.CommunicationStates.Connected & !HSPI.bShutDown); Console.WriteLine("Connection lost, exiting"); // disconnect from server for good here client.Disconnect(); clientCallback.Disconnect(); wait(2); System.Environment.Exit(0); } catch (Exception ex) { Console.WriteLine("Cannot connect(2): " + ex.Message); wait(2); System.Environment.Exit(0); return; } }
public bool Connect(string username, string password) { lock (objlock) { string ipAddress = "127.0.0.1"; Logger.LogInfo("Connecting speaker client {0} to HomeSeer IP {1}", _clientName, ipAddress); try { _client = ScsServiceClientBuilder.CreateClient <ISpeechAPI>(new ScsTcpEndPoint(ipAddress, 10401), this); _client.Disconnected += new EventHandler(ClientDisconnected); _client.Connected += new EventHandler(ClientConnected); } catch (Exception e) { Logger.LogError(e.ToString()); return(false); } try { _client.Connect(); _speakHost = _client.ServiceProxy; //make sure the interface is supported int v; try { v = _speakHost.version(); } catch (Exception e) { Logger.LogError("Error attempting to connect to server, please check your connection options: {0}", e.Message); return(false); } if (v != SPEAKER_INTERFACE_VERSION) { Logger.LogError("Speaker API version mismatch"); return(false); } //string localIp = Util.GetLocalIp(); string rval = _speakHost.Connect("Sample Plugin", _clientName, "127.0.0.1", username, password); if (!string.IsNullOrEmpty(rval)) { Logger.LogError("Error, Unable to connect speaker client interface: {0}", rval); DisconnectNow(); return(false); } } catch (Exception e) { Logger.LogError("Error while connecting speaker client: {0}", e.ToString()); return(false); } } return(true); }