public void PostedCallbacksTriggerActions() { var callback = new CallbackForTest { UniqueID = Guid.NewGuid() }; var numCallbacksRun = 0; Action <CallbackForTest> action = delegate(CallbackForTest cb) { Assert.Equal(callback.UniqueID, cb.UniqueID); numCallbacksRun++; }; using (mgr.Subscribe(action)) { for (var i = 0; i < 10; i++) { client.PostCallback(callback); } mgr.RunWaitAllCallbacks(TimeSpan.Zero); Assert.Equal(10, numCallbacksRun); // Callbacks should have been freed. mgr.RunWaitAllCallbacks(TimeSpan.Zero); Assert.Equal(10, numCallbacksRun); } }
private static void Dota() { //tell steam that we are playing dota var playGame = new ClientMsgProtobuf <CMsgClientGamesPlayed>(EMsg.ClientGamesPlayed); playGame.Body.games_played.Add(new CMsgClientGamesPlayed.GamePlayed { game_id = new GameID(570) }); steamClient.Send(playGame); //give game coordinator time Thread.Sleep(5000); //send a dota client hello message(ensures dota client has started) var clientHello = new ClientGCMsgProtobuf <CMsgClientHello>((uint)EGCBaseClientMsg.k_EMsgGCClientHello); clientHello.Body.engine = ESourceEngine.k_ESE_Source2; gameCoordinator.Send(clientHello, 570); manager.RunWaitCallbacks(TimeSpan.FromSeconds(15)); //give dota time Thread.Sleep(5000); //run a request to establish a stream SteamBotModule.CallIsPro(gameCoordinator, 36343070); dotaResponse = true; manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(5)); SteamBotModule.CallSourceTv(gameCoordinator); }
public void Run() { while (RUN_FLAG || loggedOn) { if (user != null && pass != null) { if (!attemptedToConnect) { UpdateUILabel("Connecting..."); ConnectToSteam(); attemptedToConnect = true; } else { manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(0.25)); } } if (!recieverUI.IsEmpty) { object message = null; recieverUI.TryDequeue(out message); ProcessMessage(message); } } doneClose.Set(); }
//Helper function : #region Helper function public void Run() { if (!stop) { manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(1)); } }
public SteamAPIService(ILogger <SteamCMDService> logger) { _logger = logger; // app_info_print // create our steamclient instance steamClient = new SteamClient(); // create the callback manager which will route callbacks to function calls manager = new CallbackManager(steamClient); // get the steamuser handler, which is used for logging on after successfully connecting steamUser = steamClient.GetHandler <SteamUser>(); // get our steamapps handler, we'll use this as an example of how async jobs can be handled steamApps = steamClient.GetHandler <SteamApps>(); // register a few callbacks we're interested in // these are registered upon creation to a callback manager, which will then route the callbacks // to the functions specified manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); _logger.LogInformation("Connecting to Steam..."); steamClient.Connect(); manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(15)); }
public override Result Start() { Thread.CurrentThread.Name = JsonAccount.Username + " - " + (_reportInfo != null ? "Report" : "Commend"); _freeGamesHandler = new PrimitiveFreeGamesRequestHandler(OnFreeLicenseResponse); _steamClient.AddHandler(_freeGamesHandler); _callbacks.Subscribe <SteamClient.ConnectedCallback>(OnConnected); _callbacks.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); _callbacks.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); _callbacks.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); _callbacks.Subscribe <SteamGameCoordinator.MessageCallback>(OnGCMessage); _callbacks.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); _callbacks.Subscribe <SteamUser.LoginKeyCallback>(OnNewLoginKey); IsRunning = true; _steamClient.Connect(); while (IsRunning) { _callbacks.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(500)); } return(Result); }
/// <summary> /// Blocking call to manage SteamKit CallbackManager. Blocks while m_isRunning is true. /// </summary> private void ManageCallbacks() { while (m_isRunning) { m_callbackManager.RunWaitAllCallbacks(Settings.Default.SteamCallbackManagerPeriod); waitForLastCallback.Set(); //let stop() know i've run my last callbacks. } }
public void Disconnect(bool sendLogOff = true) { if (sendLogOff) { steamUser.LogOff(); } steamClient.Disconnect(); bConnected = false; bConnecting = false; bAborted = true; // flush callbacks until our disconnected event while (!bDidDisconnect) { callbacks.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(100)); } }
private async Task CallbackManagerHandler() { while (!_cancellationTokenSource.IsCancellationRequested) { await Task.Delay(TimeSpan.FromMilliseconds(100)); CallbackManager.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(100)); } }
private bool RunClient() { // create our steamclient instance var configuration = SteamConfiguration.Create(b => b.WithProtocolTypes(ProtocolTypes.Tcp)); _steamClient = new SteamClient(configuration); // create the callback _manager which will route callbacks to function calls _manager = new CallbackManager(_steamClient); // get the steamuser handler, which is used for logging on after successfully connecting _steamUser = _steamClient.GetHandler <SteamUser>(); // get the steam friends handler, which is used for interacting with friends on the network after logging on _steamFriends = _steamClient.GetHandler <SteamFriends>(); // register a few callbacks we're interested in // these are registered upon creation to a callback _manager, which will then route the callbacks // to the functions specified _manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); _manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); _manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); _manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); // we use the following callbacks for friends related activities _manager.Subscribe <SteamUser.AccountInfoCallback>(OnAccountInfo); _manager.Subscribe <SteamFriends.FriendsListCallback>(OnFriendsList); _manager.Subscribe <SteamFriends.PersonaStateCallback>(OnPersonaState); _manager.Subscribe <SteamFriends.FriendAddedCallback>(OnFriendAdded); Console.WriteLine("Connecting to Steam..."); _isRunning = true; // initiate the connection _steamClient.Connect(); Thread.Sleep(100); // create our callback handling loop int attempts = 5; while (_isRunning && attempts > 0 && !_isMessageSent) { // in order for the callbacks to get routed, they need to be handled by the _manager _manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(5)); attempts--; } return(_isMessageSent); }
public void DoTick() { // we'll check for callbacks every 10ms // thread quantum granularity might hose us, // but it should wake often enough to handle callbacks within a single thread callbackMgr.RunWaitAllCallbacks(CallbackTimeout); if (DateTime.Now >= nextConnect) { nextConnect = DateTime.Now + TimeSpan.FromMinutes(1); Reconnecting++; Task.Run(() => Client.Connect(Server)); } }
public override Result Start() { Thread.CurrentThread.Name = JsonAccount.Username + " - " + (_reportInfo != null ? "Report" : "Commend"); _callbacks.Subscribe <SteamClient.ConnectedCallback>(OnConnected); _callbacks.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); _callbacks.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); _callbacks.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); _callbacks.Subscribe <SteamGameCoordinator.MessageCallback>(OnGCMessage); IsRunning = true; _steamClient.Connect(); while (IsRunning) { _callbacks.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(500)); } return(Result); }
public void Run() { isRunning = true; steamClient.Connect(); while (isRunning) { manager.RunWaitAllCallbacks(TimeSpan.FromSeconds(5)); if (sw.Elapsed.Seconds > 5) { Console.WriteLine("Resending CMsgClientHello"); var ClientHello = new ClientGCMsgProtobuf <CMsgClientHello>((uint)EGCBaseClientMsg.k_EMsgGCClientHello); SteamGameCoordinator.Send(ClientHello, 730); sw.Restart(); } } }
static public void joininlobby(string cfgname) { Config = JsonConvert.DeserializeObject <Config>(File.ReadAllText("data/" + cfgname)); username = Config.SteamLogin; password = Config.SteamPassword; steamClient = new SteamClient(); manager = new CallbackManager(steamClient); steamUser = steamClient.GetHandler <SteamUser>(); gameCoordinator = steamClient.GetHandler <SteamGameCoordinator>(); steamClient.AddHandler(new Handler()); _handler = steamClient.GetHandler <Handler>(); manager.Subscribe <SteamClient.ConnectedCallback>(OnConnected); manager.Subscribe <SteamClient.DisconnectedCallback>(OnDisconnected); manager.Subscribe <SteamUser.LoggedOnCallback>(OnLoggedOn); manager.Subscribe <SteamUser.LoggedOffCallback>(OnLoggedOff); manager.Subscribe <SteamUser.UpdateMachineAuthCallback>(OnMachineAuth); manager.Subscribe <SteamGameCoordinator.MessageCallback>(OnMessageCall); // Ausgeklammert, weil du das dem Handler geben musst. /*statusteam = "LobbyID to Chat?"); * lobbyid = ulong.Parse(Console.ReadLine());*/ statusteam = "Подкючаюсь к стиму..."; steamClient.Connect(); while (mainform.isjoinlobby) { manager.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(1000)); } }
/// <summary> /// 启动机器人实例 /// </summary> /// <param name="startWait">是否等待三秒后再启动,默认 <c>false</c></param> public void Start(bool startWait = false) { lock (_startStopLock) { if (_disposed) { _logger.Fatal($"#{SequenceNumber} Try to restart disposed bot."); // throw new InvalidOperationException("Try to restart disposed bot."); } if (!_callbackPumpStarted) { _callbackPumpStarted = true; Task.Run(() => { _logger.Info($"#{SequenceNumber} Listening callbacks..."); while (!_disposed) { _callbackManager.RunWaitAllCallbacks(TimeSpan.FromMilliseconds(10)); } _logger.Info($"#{SequenceNumber} Stopped listening callbacks."); }); } try { _coordinator.Consume(coordinator => coordinator.UpdateBot(Id, null, false, null)); } catch (Exception e) { _logger.Fatal($"#{SequenceNumber} Cannot clear online state before start : {e.Message}"); Restart(); return; } if (startWait) { _logger.Info($"#{SequenceNumber} Starting in 3 seconds..."); Thread.Sleep(TimeSpan.FromSeconds(3)); } var sfhPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "data", $"{LogOnDetails.Username}.sfh"); if (File.Exists(sfhPath)) { LogOnDetails.SentryFileHash = File.ReadAllBytes(sfhPath); _logger.Info($"#{SequenceNumber} Use sentry file hash from {LogOnDetails.Username}.sfh."); } if (!_loginPending) { LoginSemaphore.WaitOne(); _loginPending = true; } SteamClient.Connect(); _mqChannel = _mqClientProvider.CreateModel(); _mqChannel.BasicQos(0, 5, false); var queueName = MqClientProvider.SteamBotDelayedActionQueue(Id); _mqChannel.QueueDeclare(queueName, true, false, false, null); _mqChannel.QueueBind(queueName, MqClientProvider.DelayedMessageExchange, queueName); var consumer = new EventingBasicConsumer(_mqChannel); consumer.Received += OnDelayedActionReceived; _mqChannel.BasicConsume(queueName, false, consumer); } }