public override void Start() { try { if (Listener?.Running == true) { return; } bool ret = connected ? true : Connect(ConnectTimeout); if (ret) { Listener = new TcpListener(this); Listener.Start(); } if (Listener?.Running == true) { OnStarted?.Invoke(new NetClientEventArgs <ITcpConnection>(this)); } } catch (Exception ex) { OnException?.Invoke(new NetClientEventArgs <ITcpConnection>(this) { Exception = ex }); if (!connected) { throw ex; } } }
public void Start() { clientList = new List <TcpClient>(); listener = new TcpListener(ipEndPoint); listener.Start(); alive = true; runner = new Thread(new ThreadStart(Run)); runner.IsBackground = true; runner.Name = "Tcp Listener Runner"; runner.Start(); while (!runner.IsAlive) { Thread.Sleep(10); } acceptor = new Thread(new ThreadStart(Accept)); acceptor.IsBackground = true; acceptor.Name = "Tcp Listener Acceptor"; acceptor.Start(); while (!acceptor.IsAlive) { Thread.Sleep(10); } if (OnStarted != null) { OnStarted.Invoke(); } }
public void SwitchState() { State next = State.idle; switch (_State) { case State.idle: next = State.started; _StartedAt = DateTime.Now; OnStarted?.Invoke(); break; case State.paused: next = State.started; _PauseSum += DateTime.Now - _PausedAt; _PausedAt = new DateTime(); OnStarted?.Invoke(); break; case State.started: next = State.paused; _PausedAt = DateTime.Now; OnPaused?.Invoke(); break; } _State = next; }
internal override void InvokeEvent(ServerType type, IConnection conn, IMessage msg) { switch (type) { case ServerType.Started: OnStarted?.Invoke(conn, msg); break; case ServerType.Accepted: OnAccepted?.Invoke(conn, msg); break; case ServerType.Sended: OnSended?.Invoke(conn, msg); break; case ServerType.Received: OnRecieved?.Invoke(conn, msg); break; case ServerType.Disconnected: OnDisconnected?.Invoke(conn, msg); break; case ServerType.Stopped: OnStopped?.Invoke(conn, msg); break; } }
/// <summary> /// Run code in a new worker thread. WorkerDelegate should return true to end, false to repeat. /// </summary> /// <param name="worker">Delegate to be run</param> /// <param name="waitTime"></param> public static void Start(Func <bool> worker, int waitTime = 25) { if (IsRunning) { return; } WaitTime = waitTime; var frame = new StackFrame(1); var method = frame.GetMethod(); var type = method.DeclaringType; var ns = type != null ? type.Namespace : string.Empty; _worker = worker; _thread = new Thread(SafeWorkerDelegate) { Name = $"Worker: {ns}.{type}", IsBackground = true, Priority = ThreadPriority.BelowNormal, }; Core.Logger.Debug("Starting {0} Thread Id={1}", _thread.Name, _thread.ManagedThreadId); _working = true; _thread.Start(); OnStarted.Invoke(); }
/// <summary> /// Run code in a new worker thread. WorkerDelegate should return true to end, false to repeat. /// </summary> /// <param name="worker">Delegate to be run</param> public void Start(WorkerDelegate worker) { if (IsRunning) { return; } var frame = new StackFrame(1); var method = frame.GetMethod(); var type = method.DeclaringType; var ns = type != null ? type.Namespace : string.Empty; _worker = worker; _thread = new Thread(SafeWorkerDelegate) { Name = string.Format("Worker: {0}.{1}", ns, type), IsBackground = true, Priority = ThreadPriority.BelowNormal, }; Logger.Debug("Starting {0} Thread Id={1}", _thread.Name, _thread.ManagedThreadId); _working = true; _thread.Start(); OnStarted.Invoke(); }
public void Start(IPAddress address, int port) { if (IsClosing || IsWorking) { throw new InvalidOperationException("Listener must be closed before executing Start method."); } if (address is null || port == 0) { throw new ArgumentNullException(); } OnStarting?.Invoke(this, new ListenerEventArgs { Server = this, UtcTime = DateTime.UtcNow }); // IP Check if ( NetworkInterface .GetAllNetworkInterfaces() .Where(interf => interf.OperationalStatus == OperationalStatus.Up) .Select(interf => new { uni = interf.GetIPProperties().UnicastAddresses, multi = interf.GetIPProperties().MulticastAddresses }) .Where(item => item.uni.Where(ip => ip.Address == address).Count() > 0 || item.multi.Where(ip => ip.Address == address).Count() > 0 ) .Count() == 0 ) { throw new ArgumentException("This IP address isn't assigned to active interface"); } IPEndPoint endpoint = new IPEndPoint(address, port); this.socket = new Socket(endpoint.AddressFamily, SocketType.Stream, ProtocolType.Tcp); this.socket.Bind(endpoint); this.socket.Listen(50); CurrentPassword = GeneratePassword(); OnStarted.Invoke( this, new ListenerEventArgs { Server = this, UtcTime = DateTime.UtcNow } ); new Thread(() => { while (!IsClosing) { socket.BeginAccept(new AsyncCallback(AcceptCallback), socket); } }); }
///////////////////////////////////// // Public ///////////////////////////////////// public bool Start(int port = 7788) { try { Host = new SimpleTcpServer(); //Host.Delimiter //Host.DelimiterDataReceived += (o, e) => { Console.WriteLine("Delimter data received"); }; //Host.DataReceived += (o, e) => { Console.WriteLine("##############Data received"); }; //Host.DataReceived += DataReceived; Host.DelimiterDataReceived += DataReceived; Host.ClientConnected += ClientConnected; Host.Start(port); disconnectPing.Start(); InvokeOutput("Server Started."); if (!hasConnectedBefore) { hasConnectedBefore = true; Application.Current.MainWindow.Closed += Program_Exit; } OnStarted?.Invoke(); return(true); } catch (Exception ex) { Console.WriteLine("Warning#001 :" + ex.Message); InvokeOutput("Server Not Started."); return(false); } }
public void StartListening(string ip, string port) { _webSocketServer = new WebSocketServer($"ws://{ip}:{port}"); AddWsServerService(); _webSocketServer.Start(); OnStarted?.Invoke(this, EventArgs.Empty); }
async void ToggleAnimation() { if (IsRunning) { if (OnStartedAnimation != null) { await OnStartedAnimation.Begin(); } ToggleIndicator(IsRunning); OnStarted?.Invoke(this, null); } else { if (OnCompletedAnimation != null) { await OnCompletedAnimation.Begin(); } ToggleIndicator(IsRunning); OnCompleted?.Invoke(this, null); } void ToggleIndicator(bool isRunning) { IsVisible = _loadingIndicator.IsVisible = _loadingIndicator.IsRunning = IsRunning; Opacity = 1; } }
public IGraphPath FindPath() { OnStarted?.Invoke(this, new AlgorithmEventArgs()); OnVertexVisited?.Invoke(this, new AlgorithmEventArgs()); OnVertexEnqueued?.Invoke(this, new AlgorithmEventArgs()); OnFinished?.Invoke(this, new AlgorithmEventArgs()); return(new NullGraphPath()); }
private void MessagingStartedHandle(MessagingStartedData value) { synchronization.Post(async state => { var connection = await CreateConnectionAsync(myId, value.SecurityKey); OnStarted?.Invoke(this, new StartMessagingConnectionEventArgs(connection, value.UserId)); }, value); }
private async Task Start() { CurrentPhase = Phase.Running; if (_users.Count <= 1) { foreach (var user in _users) { if (user.Bet > 0) { await _currency.AddAsync(user.UserId, "Race refund", user.Bet).ConfigureAwait(false); } } var _sf = OnStartingFailed?.Invoke(this); CurrentPhase = Phase.Ended; return; } var _ = OnStarted?.Invoke(this); var _t = Task.Run(async() => { var rng = new NadekoRandom(); while (!_users.All(x => x.Progress >= 60)) { foreach (var user in _users) { user.Progress += rng.Next(1, 11); if (user.Progress >= 60) { user.Progress = 60; } } var finished = _users.Where(x => x.Progress >= 60 && !FinishedUsers.Contains(x)) .Shuffle(); FinishedUsers.AddRange(finished); var _ignore = OnStateUpdate?.Invoke(this); await Task.Delay(2500).ConfigureAwait(false); } var win_amount = 0; foreach (var u in FinishedUsers) { win_amount += (int)u.Bet; } if (FinishedUsers[0].Bet > 0) { await _currency.AddAsync(FinishedUsers[0].UserId, "Won a Race", win_amount) .ConfigureAwait(false); } var _ended = OnEnded?.Invoke(this); }); }
public static async void Start(IConfigurationRoot configuration, IServiceProvider services) { SystemController.configuration = configuration; SystemController.services = services; if (Boolean.Parse(configuration["FirstRun"])) { if (!firstRun) { firstRun = true; Console.ForegroundColor = ConsoleColor.Cyan; Console.WriteLine("\nWelcome to MyNodes.NET. \nPlease configure the system in the web interface.\n"); Console.ForegroundColor = ConsoleColor.Gray; } return; } if (systemControllerStarted) { return; } systemControllerStarted = true; //read settings ReadConfig(); await Task.Run(() => { //waiting for starting web server Thread.Sleep(500); logs.AddSystemInfo("---------------- STARTING ------------------"); if (nodesDb == null) { ConnectToDB(); } if (gateway == null) { ConnectToGateway(); } if (nodesEngine == null) { StartNodesEngine(); } logs.AddSystemInfo("------------- SARTUP COMPLETE --------------"); OnStarted?.Invoke(); }); }
void StartSystem() { for (int i = 0; i < _systems.Count; ++i) { _systems[i].StartSystem(this); } OnStarted?.Invoke(); }
private void MessagingStartingHandle(MessagingStartingData value) { synchronization.Post(async state => { var securityKey = GenerateSecurityKey(); var connection = await CreateConnectionAsync(myId, securityKey); await roomConnection.StartMessagingAsync(value.UserId, securityKey); OnStarted?.Invoke(this, new StartMessagingConnectionEventArgs(connection, value.UserId)); }, value); }
/// <summary> /// Setup and run the story using the parents cancellationTokenSource & refreshRate /// </summary> /// <returns></returns> public void Start(CancellationTokenSource cancellationTokenSource, RefreshRate refreshRate) { RefreshRate = refreshRate; StepCount = (int)Duration.TotalMilliseconds / (int)RefreshRate; CancellationTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationTokenSource.Token); Setup(); State = StoryState.Running; OnStarted?.Invoke(this, EventArgs.Empty); Begin(); }
public void Start(int bot) { if (!_run) { if (_wordlist == null) { throw new Exception("Wordlist is null."); } if (!_wordlist.HasNext) { throw new Exception("Wordlist is null."); } _theEnd = false; _run = true; _threadList.Clear(); _bot = bot; if (_bot > _wordlist.Count - _position) { _bot = _wordlist.Count - _position; } _runnerStatus = RunnerStatus.Started; try { OnStarted?.Invoke(this, new StartEventArgs() { Bot = _bot }); } catch (Exception ex) { OnException?.Invoke(this, new ExceptionEventArgs() { Location = "OnStarted", Exception = ex, Log = _log }); } _stopwatch.Restart(); _stopwatch.Start(); _cts = new CancellationTokenSource(); for (int i = 0; i < _bot; i++) { int num = i; Thread thread = new Thread(() => { Config(num, _cts.Token); }) { IsBackground = true, Name = $"ID{num}" }; thread.Start(); _threadList.Add(thread); } new Thread(() => { CompletedTask(); }) { IsBackground = true }.Start(); } }
public void Start() { if (Math.Abs(Interval) < 0.001) { return; } OnStarted?.Invoke(this, new GameTimerEventArgs(TotalSeconds, Interval)); IsStopped = false; IsStarted = true; }
public PanoDownloader() { m_UserDownloader = new UserPanoDownloader(); m_GoogleDownloader = new GooglePanoDownloader(); m_UserDownloader.OnStarted += () => OnStarted?.Invoke(); m_UserDownloader.OnLoaded += tex => OnLoaded?.Invoke(tex); m_UserDownloader.OnFailed += exception => OnFailed?.Invoke(exception); m_GoogleDownloader.OnStarted += () => OnStarted?.Invoke(); m_GoogleDownloader.OnLoaded += tex => OnLoaded?.Invoke(tex); m_GoogleDownloader.OnFailed += exception => OnFailed?.Invoke(exception); }
public void Start() { if (Status != WorkerStatus.Stopped) { throw new InvalidOperationException("Worker must be stopped in order to start it"); } Status = WorkerStatus.Starting; _cancellationTokenSource = new CancellationTokenSource(); _worker = _workerWrapper(_cancellationTokenSource.Token); OnStarted?.Invoke(this, new EventArgs()); }
/// <summary> /// IRC event: authenticated was OK, and we received a welcome message from the server. /// </summary> private void Client_Registered(object sender, EventArgs e) { TmiLog.Log("Authed on Twitch IRC server."); if (Status == ClientStatus.Connecting) { Status = ClientStatus.Started; } if (OnStarted != null) { OnStarted.Invoke(this, new EventArgs()); } }
protected override Task SerializeToStreamAsync(Stream stream, TransportContext context) { var length = m_Bytes.Length; return(Task.Run(() => { OnStarted?.Invoke(); for (var i = 0; i < length; i += k_ChunkSize) { var count = Math.Min(k_ChunkSize, length - i); stream.Write(m_Bytes, i, count); OnProgress?.Invoke(i + count); } })); }
/// <summary> /// Initialize and start objective /// </summary> public virtual void start() { Tools.log("Start " + getName()); if (this.inProgress) { return; } elapsedTime = 0; this.play(); OnStarted?.Invoke(this); }
private void ThriftRpcProcess_OutputDataReceived(object sender, DataReceivedEventArgs e) { Process process = (Process)sender; ThriftRpcLog.Info($"RpcAgent({process.Id}): {e.Data}"); OnMessage?.Invoke(process, e.Data); const string startString = "Starting the rpc server on"; if (e.Data != null && e.Data.Contains(startString)) { Log.InfoFormat("Found magic string \"{0}\" indicating that RPC Agent {1} has started successfully", startString, process.Id); OnStarted?.Invoke(this, EventArgs.Empty); } }
public bool Start(DateTimeOffset lastKnownEvent = default(DateTimeOffset)) { if (!ScheduledTask.IsScheduleRunning) { ScheduledTask.StartSchedule(lastKnownEvent); OnStarted?.Invoke(this, new WorkerStartedEventArgs()); Store($"{Name} has started at {DateTime.Now}"); return(true); } return(false); }
private bool ConnectInternal() { try { if (Listener?.Running == true) { return(true); } bool ret = connected ? true : Connect(ConnectTimeout); if (ret) { tryConnectCounter = 0; Listener = new TcpListener(this); Listener.Start(); } if (Listener?.Running == true) { OnStarted?.Invoke(new NetClientEventArgs <ITcpConnection>(this)); } if (ret) { if (!started) { started = true; } return(true); } } catch (Exception ex) { OnException?.Invoke(new NetClientEventArgs <ITcpConnection>(this) { Exception = ex }); if (!connected && !created && !connecting) { throw ex; } //if (!started && !connected && ReconnectEnable && created) Reconnect(); } return(false); }
/// <summary> /// Start the TCPServer thread /// </summary> public void Start(UInt32 MaxClientConnections) { if (_IsRunning) { return; } if (MaxClientConnections != __DefaultMaxClientConnections) { _MaxClientConnections = MaxClientConnections; } try { Debug.WriteLine("[" + DateTime.Now + "] Starting TCP listener on port " + _Port); _TCPListener.Start((Int32)_MaxClientConnections); } catch (Exception e) { Debug.WriteLine("[" + DateTime.Now + "] An exception occured in Hermod.TCPServer.Start(MaxClientConnections) [_TCPListener.Start((Int32) _MaxClientConnections)]: " + e.Message + Environment.NewLine + e.StackTrace); } try { if (_ListenerThread == null) { Debug.WriteLine("[" + DateTime.Now + "] An exception occured in Hermod.TCPServer.Start(MaxClientConnections) [_ListenerThread == null]!"); } // Start the TCPListenerThread _ListenerThread.Start(); } catch (Exception e) { Debug.WriteLine("[" + DateTime.Now + "] An exception occured in Hermod.TCPServer.Start(MaxClientConnections) [_ListenerThread.Start()]: " + e.Message + Environment.NewLine + e.StackTrace); } // Wait until socket has opened while (!_IsRunning) { Thread.Sleep(10); } OnStarted?.Invoke(this, DateTime.Now); }
public async Task Start(bool UseExamples, string ProfileNameSetting, string LicenseKeySetting) { configuration = new Oridashi.Fhir.Host.Configuration() { ProfileName = ProfileNameSetting, LicenseKey = LicenseKeySetting, Mode = Oridashi.Fhir.Host.Configuration.SelectSystem.AUTO, IsLive = !UseExamples, }; host = new Oridashi.Fhir.Host.FhirHost(); await Task <Oridashi.Fhir.Host.Configuration> .Run(new Action(() => { configuration = host.Start(configuration); running = true; OnStarted?.Invoke(); })); }
private void AtmptStart() { if (List_PendingToStart.Count > 0 && Vacancy > 0) { var load = List_PendingToStart.First(); Log("Start", load); if (DebugMode) { Debug.WriteLine("{0}:\t{1}\tStart\t{2}", ClockTime, this, load); } List_PendingToStart.RemoveAt(0); HSet_Serving.Add(load); HC_Serving.ObserveChange(1, ClockTime); OnStarted.Invoke(load); Schedule(() => ReadyToDepart(load), Assets.ServiceTime(DefaultRS, load)); } }