public void ExecuteAsyncCommands(IEnumerable <ICommandMapping> mappings, CommandPayload payload) { _commandMappingQueue = new Queue <ICommandMapping>(mappings); _totalCommandsCount = _commandMappingQueue.Count; _payload = payload; ExecuteNextCommand(); }
public short Run() { CommandPayload payload = new CommandPayload(); payload.Type = CommandPayloadType.Sql; payload.Text = ToString(); payload.NonTextLimit = -1; payload.FetchPlan = ""; payload.SerializedParams = new byte[] { 0 }; Command operation = new Command(); operation.OperationMode = OperationMode.Synchronous; operation.ClassType = CommandClassType.NonIdempotent; operation.CommandPayload = payload; OCommandResult result = new OCommandResult(_connection.ExecuteOperation(operation)); var clusterId = short.Parse(result.ToDocument().GetField <string>("Content")); _connection.Database.AddCluster(_className, clusterId); if (_autoProperties) { CreateAutoProperties(); } return(clusterId); }
/// <summary> /// Enqueue a payload to be sent over the websocket /// If the websocket is connected it will be sent immediately /// If the websocket is not connected it will be queued until it is back online /// </summary> /// <param name="command">Command to send over the websocket</param> public void Enqueue(CommandPayload command) { if (_logger.IsLogging(DiscordLogLevel.Debug)) { _logger.Debug($"{nameof(SocketCommandHandler)}.{nameof(Enqueue)} Queuing command {command.OpCode.ToString()}"); } //If websocket has connect and we need to identify or resume send those payloads right away if (_webSocket.IsConnected() && (command.OpCode == GatewayCommandCode.Identify || command.OpCode == GatewayCommandCode.Resume)) { _webSocket.Send(command); return; } //If the websocket isn't fully connect enqueue the command until it is ready if (!_socketCanSendCommands) { if (command.OpCode == GatewayCommandCode.PresenceUpdate) { RemoveByType(GatewayCommandCode.PresenceUpdate); } else if (command.OpCode == GatewayCommandCode.VoiceStateUpdate) { RemoveByType(GatewayCommandCode.VoiceStateUpdate); } AddCommand(command); return; } AddCommand(command); SendCommands(); }
/// <summary> /// Executes the commands on the input data read from input stream /// and writes results to the output stream. /// </summary> /// <param name="inputStream">Input stream to read data from</param> /// <param name="outputStream">Output stream to write results to</param> /// <param name="splitIndex">Split index for this task</param> /// <param name="commandPayload">Contains the commands to execute</param> /// <returns>Statistics captured during the Execute() run</returns> internal CommandExecutorStat Execute( Stream inputStream, Stream outputStream, int splitIndex, CommandPayload commandPayload) { if (commandPayload.EvalType == Spark.Utils.UdfUtils.PythonEvalType.NON_UDF) { if (commandPayload.Commands.Length != 1) { throw new System.Exception( "Invalid number of commands for RDD: {commandPayload.Commands.Length}"); } return(new RDDCommandExecutor().Execute( inputStream, outputStream, splitIndex, (RDDCommand)commandPayload.Commands[0])); } return(SqlCommandExecutor.Execute( inputStream, outputStream, commandPayload.EvalType, commandPayload.Commands.Cast <SqlCommand>().ToArray())); }
/*============================================================================*/ /* Public Functions */ /*============================================================================*/ public void ExecuteCommands(IEnumerable <ICommandMapping> mappings, CommandPayload payload = null) { foreach (ICommandMapping mapping in mappings) { ExecuteCommand(mapping, payload); } }
private void SendCommands() { lock (_syncRoot) { while (_pendingCommands.Count != 0) { CommandPayload payload = _pendingCommands[0]; if (_rateLimit.HasReachedRateLimit) { if (!_rateLimitTimer.Enabled) { _rateLimitTimer.Interval = _rateLimit.NextReset; _rateLimitTimer.Stop(); _rateLimitTimer.Start(); _logger.Warning($"{nameof(SocketCommandHandler)}.{nameof(SendCommands)} Rate Limit Hit! Retrying in {_rateLimit.NextReset.ToString()} seconds\nOpcode: {payload.OpCode}\nPayload: {JsonConvert.SerializeObject(payload.Payload, DiscordExtension.ExtensionSerializeSettings)}"); } return; } if (_logger.IsLogging(DiscordLogLevel.Debug)) { _logger.Debug($"{nameof(SocketCommandHandler)}.{nameof(SendCommands)} Sending Command {payload.OpCode.ToString()}"); } if (!_webSocket.Send(payload)) { return; } _pendingCommands.RemoveAt(0); _rateLimit.FiredRequest(); } } }
public short Run() { if (string.IsNullOrEmpty(_class)) { throw new OException(OExceptionType.Query, "Class is empty"); } CommandPayload payload = new CommandPayload(); payload.Type = CommandPayloadType.Sql; payload.Text = ToString(); payload.NonTextLimit = -1; payload.FetchPlan = ""; payload.SerializedParams = new byte[] { 0 }; Command operation = new Command(); operation.OperationMode = OperationMode.Synchronous; operation.ClassType = CommandClassType.NonIdempotent; operation.CommandPayload = payload; OCommandResult result = new OCommandResult(_connection.ExecuteOperation(operation)); return(short.Parse(result.ToDocument().GetField <string>("Content"))); }
/// <summary> /// Enqueue a payload to be sent over the websocket /// If the websocket is connected it will be sent immediately /// If the websocket is not connected it will be queued until it is back online /// </summary> /// <param name="command">Command to send over the websocket</param> public void Enqueue(CommandPayload command) { if (_logger.IsLogging(DiscordLogLevel.Debug)) { _logger.Debug($"{nameof(SocketCommandHandler)}.{nameof(Enqueue)} Queuing command {command.OpCode.ToString()}"); } if (_webSocket.IsConnected()) { _pendingCommands.Add(command); SendCommands(); return; } if (command.OpCode == GatewayCommandCode.PresenceUpdate) { _pendingCommands.RemoveAll(p => p.OpCode == GatewayCommandCode.PresenceUpdate); } else if (command.OpCode == GatewayCommandCode.VoiceStateUpdate) { _pendingCommands.RemoveAll(p => p.OpCode == GatewayCommandCode.VoiceStateUpdate); } _pendingCommands.Add(command); }
/*============================================================================*/ /* Private Functions */ /*============================================================================*/ private void MapPayload(CommandPayload payload) { int i = (int)payload.length; while (i-- > 0) { _injector.Map(payload.Classes [i]).ToValue(payload.Values [i]); } }
private void UnmapPayload(CommandPayload payload) { int i = (int)payload.length; while (i-- > 0) { _injector.Unmap(payload.Classes [i]); } }
/// <summary> /// Send a command to discord over the websocket /// </summary> /// <param name="opCode">Command code to send</param> /// <param name="data">Data to send</param> public void Send(GatewayCommandCode opCode, object data) { CommandPayload payload = new CommandPayload { OpCode = opCode, Payload = data }; _commands.Enqueue(payload); }
public void payload_is_passed_to_execute_method() { addMapping <MethodParametersCommand>(); CommandPayload payload = new CommandPayload(new List <object> { "message", 1 }, new List <Type> { typeof(String), typeof(int) }); executeCommands(payload); Assert.That(reported, Is.EqualTo(payload.Values).AsCollection); }
public void payload_is_injected_into_guard() { addMapping <NullCommand>().AddGuards <PayloadInjectionPointsGuard>(); CommandPayload payload = new CommandPayload(new List <object> { "message", 1 }, new List <Type> { typeof(String), typeof(int) }); executeCommands(payload); Assert.That(reported, Is.EqualTo(payload.Values).AsCollection); }
private void AddCommand(CommandPayload command) { lock (_syncRoot) { if (command.OpCode == GatewayCommandCode.Identify || command.OpCode == GatewayCommandCode.Resume) { _pendingCommands.Insert(0, command); return; } _pendingCommands.Add(command); } }
public void payload_doesnt_leak_into_class_instantiated_by_command() { injector.Map <IInjector>().ToValue(injector); addMapping <OptionalInjectionPointsCommandInstantiatingCommand>(); CommandPayload payload = new CommandPayload(new List <object> { "message", 1 }, new List <Type> { typeof(String), typeof(int) }); executeCommands(payload); Assert.That(reported, Is.EqualTo(new object[] { null, 0 }).AsCollection); }
public void payloadInjection_is_disabled() { addMapping <OptionalInjectionPointsCommand>() .SetPayloadInjectionEnabled(false); CommandPayload payload = new CommandPayload(new List <object> { "message", 1 }, new List <Type> { typeof(String), typeof(int) }); executeCommands(payload); Assert.That(reported, Is.EqualTo(new object[] { null, 0 }).AsCollection); }
private CommandResult HandleCommand(State state, CommandPayload payload) { switch (payload) { case CreateAuction createAuction: return(CreateAuctionHandler.Handle(state, createAuction)); case PlaceBid placeBid: return(PlaceBidHandler.Handle(state, placeBid)); default: return(CommandResultFailure.Create("Unknown command payload type")); } }
public void ExecuteCommand(ICommandMapping mapping, CommandPayload payload = null) { bool hasPayload = payload != null && payload.HasPayload(); bool injectionEnabled = hasPayload && mapping.PayloadInjectionEnabled; object command = null; if (injectionEnabled) { MapPayload(payload); } if (mapping.Guards.Count == 0 || Guards.Approve(_injector, mapping.Guards)) { Type commandClass = mapping.CommandClass; if (mapping.FireOnce && _removeMapping != null) { _removeMapping(mapping); } command = _injector.GetOrCreateNewInstance(commandClass); if (mapping.Hooks.Count > 0) { _injector.Map(commandClass).ToValue(command); Hooks.Apply(_injector, mapping.Hooks); _injector.Unmap(commandClass); } } if (injectionEnabled) { UnmapPayload(payload); } if (command != null && mapping.ExecuteMethod != null) { if (_onPreprocessCommandExecuting != null) { _onPreprocessCommandExecuting.Invoke(command, mapping); } MethodInfo executeMethod = command.GetType().GetMethod(mapping.ExecuteMethod); object result = (hasPayload && executeMethod.GetParameters().Length > 0) ? executeMethod.Invoke(command, payload.Values.ToArray()) : executeMethod.Invoke(command, null); if (_handleResult != null) { _handleResult.Invoke(result, command, mapping); } } }
private void MemoryIndexGetButton_Click(object sender, EventArgs e) { if (serialPort.IsOpen) { var payload = new CommandPayload(); payload.Command = FrameCommand.Read; payload.Address = FrameAddress.LatestMemoryInformation; var frame = new Frame(payload); var buffer = frame.ToBytes(); serialPort.Write(buffer, 0, buffer.Length); } else { Console.WriteLine("閉じてる"); } }
internal bool Send(CommandPayload payload) { string payloadData = JsonConvert.SerializeObject(payload, DiscordExtension.ExtensionSerializeSettings); if (_logger.IsLogging(DiscordLogLevel.Verbose)) { _logger.Verbose($"{nameof(Socket)}.{nameof(Send)} Payload: {payloadData}"); } if (_socket == null) { return(false); } _socket.SendAsync(payloadData, null); return(true); }
void dropPayload() { print("reached target, dropping envelope"); GetComponent <MeshRenderer> ().materials = new Material[] { noEnvelopeMaterial }; Quaternion orientation = Quaternion.Euler(0, 0, 0); Vector3 dropPosition = targetPosition; dropPosition.y = rb.position.y - 0.1f; Vector3 v = rb.velocity; // don't let the envelope be seen! v.y = 0; rb.velocity = v; Transform envObj = Instantiate(envelope, position: dropPosition, rotation: orientation); Envelope env = envObj.GetComponent <Envelope> (); env.payload = payload; this.payload = null; env.playerId = this.playerId; }
private IEnumerable <ODocument> Run() { CommandPayload payload = new CommandPayload(); payload.Type = CommandPayloadType.Sql; payload.Text = query; payload.NonTextLimit = -1; payload.FetchPlan = "*:0"; payload.SerializedParams = new byte[] { 0 }; Command operation = new Command(); operation.OperationMode = OperationMode.Asynchronous; operation.ClassType = CommandClassType.Idempotent; operation.CommandPayload = payload; ODocument document = _connection.ExecuteOperation(operation); return(document.GetField <List <ODocument> >("Content")); }
public List <ODocument> ToList(string fetchPlan) { CommandPayload payload = new CommandPayload(); payload.Type = CommandPayloadType.Sql; payload.Text = ToString(); payload.NonTextLimit = -1; payload.FetchPlan = fetchPlan; payload.SerializedParams = new byte[] { 0 }; Command operation = new Command(); operation.OperationMode = OperationMode.Asynchronous; operation.ClassType = CommandClassType.Idempotent; operation.CommandPayload = payload; OCommandResult commandResult = new OCommandResult(_connection.ExecuteOperation <Command>(operation)); return(commandResult.ToList()); }
/// <summary> /// Reads the given stream to construct a CommandPayload object. /// </summary> /// <param name="stream">The stream to read from</param> /// <returns>CommandPayload object</returns> internal CommandPayload Process(Stream stream) { var evalType = (PythonEvalType)SerDe.ReadInt32(stream); var commandPayload = new CommandPayload() { EvalType = evalType }; if (evalType == PythonEvalType.NON_UDF) { commandPayload.Commands = new[] { ReadRDDCommand(stream) }; } else { commandPayload.Commands = ReadSqlCommands(evalType, stream, _version); } return(commandPayload); }
public OCommandResult Command(string sql) { CommandPayload payload = new CommandPayload(); payload.Type = CommandPayloadType.Sql; payload.Text = sql; payload.NonTextLimit = -1; payload.FetchPlan = ""; payload.SerializedParams = new byte[] { 0 }; Command operation = new Command(); operation.OperationMode = OperationMode.Synchronous; operation.ClassType = CommandClassType.NonIdempotent; operation.CommandPayload = payload; ODocument document = _connection.ExecuteOperation(operation); return(new OCommandResult(document)); }
public List <ODocument> Query(string sql, string fetchPlan) { CommandPayload payload = new CommandPayload(); payload.Type = CommandPayloadType.Sql; payload.Text = sql; payload.NonTextLimit = -1; payload.FetchPlan = fetchPlan; payload.SerializedParams = new byte[] { 0 }; Command operation = new Command(); operation.OperationMode = OperationMode.Asynchronous; operation.ClassType = CommandClassType.Idempotent; operation.CommandPayload = payload; ODocument document = _connection.ExecuteOperation(operation); return(document.GetField <List <ODocument> >("Content")); }
public int Run() { CommandPayload payload = new CommandPayload(); payload.Type = CommandPayloadType.Sql; payload.Text = ToString(); payload.NonTextLimit = -1; payload.FetchPlan = ""; payload.SerializedParams = new byte[] { 0 }; Command operation = new Command(); operation.OperationMode = OperationMode.Synchronous; operation.ClassType = CommandClassType.NonIdempotent; operation.CommandPayload = payload; OCommandResult result = new OCommandResult(_connection.ExecuteOperation <Command>(operation)); return(int.Parse(result.ToDocument().GetField <string>("Content"))); }
public OVertex Run() { CommandPayload payload = new CommandPayload(); payload.Type = CommandPayloadType.Sql; payload.Text = ToString(); payload.NonTextLimit = -1; payload.FetchPlan = ""; payload.SerializedParams = new byte[] { 0 }; Command operation = new Command(); operation.OperationMode = OperationMode.Synchronous; operation.ClassType = CommandClassType.NonIdempotent; operation.CommandPayload = payload; OCommandResult result = new OCommandResult(_connection.ExecuteOperation(operation)); return(result.ToSingle().To <OVertex>()); }
void deliverMessage() { if (this.payload != null) { if (this.payload.Solider != null) { if (this.payload.Solider.Team == PlayerId.PlayerA) { SoundManager.instance.RandomizeSfx(catEFX1, catEFX2); // Add efx } else { SoundManager.instance.RandomizeSfx(dogEFX1, dogEFX2); } this.payload.Solider.ExecuteCommand(this.payload.direction, this.payload.FinalPosition); } this.payload = null; //GameManager.Instance.PayloadDelivered(this.playerId); } Destroy(gameObject); }
public List <ODocument> Gremlin(string query) { CommandPayload payload = new CommandPayload(); payload.Language = "gremlin"; payload.Type = CommandPayloadType.Sql; payload.Text = query; payload.NonTextLimit = -1; payload.FetchPlan = ""; payload.SerializedParams = new byte[] { 0 }; Command operation = new Command(); operation.OperationMode = OperationMode.Asynchronous; operation.ClassType = CommandClassType.NonIdempotent; operation.CommandPayload = payload; ODocument document = _connection.ExecuteOperation(operation); return(document.GetField <List <ODocument> >("Content")); }