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"));
}
