public virtual async Task <IActionResult> Post([FromBody] QueryPayload query)
{
if (query == null)
{
throw new ArgumentNullException(nameof(query));
}
var inputs = query.Variables.ToInputs();
var executionOptions = new ExecutionOptions
{
Schema = _schema,
Query = query.Query,
OperationName = query.OperationName,
Inputs = inputs,
UserContext = new GraphQLUserContext
{
DependencyResolver = _dependencyResolver
},
};
executionOptions.Listeners.Add(_dataLoaderListener);
executionOptions.ThrowOnUnhandledException = true;
var result = await _documentExecuter.ExecuteAsync(executionOptions).ConfigureAwait(false);
if (result.Errors?.Count > 0)
{
return(BadRequest(result));
}
return(Ok(result));
}
private async Task GetRealServerDetailsAsync(IOBehavior ioBehavior, CancellationToken cancellationToken)
{
try
{
await SendAsync(QueryPayload.Create("SELECT CONNECTION_ID(), VERSION();"), ioBehavior, cancellationToken).ConfigureAwait(false);
// column count: 2
await ReceiveReplyAsync(ioBehavior, cancellationToken).ConfigureAwait(false);
// CONNECTION_ID() and VERSION() columns
await ReceiveReplyAsync(ioBehavior, CancellationToken.None).ConfigureAwait(false);
await ReceiveReplyAsync(ioBehavior, CancellationToken.None).ConfigureAwait(false);
PayloadData payload;
if (!SupportsDeprecateEof)
{
payload = await ReceiveReplyAsync(ioBehavior, CancellationToken.None).ConfigureAwait(false);
EofPayload.Create(payload);
}
// first (and only) row
int? connectionId = default;
string serverVersion = null;
payload = await ReceiveReplyAsync(ioBehavior, CancellationToken.None).ConfigureAwait(false);
var reader = new ByteArrayReader(payload.ArraySegment);
var length = reader.ReadLengthEncodedIntegerOrNull();
if (length != -1)
{
connectionId = int.Parse(Encoding.UTF8.GetString(reader.ReadByteString(length)), CultureInfo.InvariantCulture);
}
length = reader.ReadLengthEncodedIntegerOrNull();
if (length != -1)
{
serverVersion = Encoding.UTF8.GetString(reader.ReadByteString(length));
}
// OK/EOF payload
payload = await ReceiveReplyAsync(ioBehavior, CancellationToken.None).ConfigureAwait(false);
if (OkPayload.IsOk(payload, SupportsDeprecateEof))
{
OkPayload.Create(payload, SupportsDeprecateEof);
}
else
{
EofPayload.Create(payload);
}
if (connectionId.HasValue && serverVersion != null)
{
ConnectionId = connectionId.Value;
ServerVersion = new ServerVersion(serverVersion);
}
}
catch (MySqlException)
{
}
}
public void Observe <T1, T2, T3, T4, T5, T6>(dynamic query, Action <T1, T2, T3, T4, T5, T6> callback)
where T1 : Device
where T2 : Device
where T3 : Device
where T4 : Device
where T5 : Device
where T6 : Device
{
var queryPayload = new QueryPayload();
queryPayload.Query = query;
queryPayload.Callback = async(input) => {
var devices = Serializer.DeserializeArray((string)input, new[] { typeof(IdentityDevice), typeof(IdentityDevice) }, 2).ToArray();
var first = MemoryRegistry.Instance.Get <T1>(devices[0].Id);
var second = MemoryRegistry.Instance.Get <T2>(devices[1].Id);
var third = MemoryRegistry.Instance.Get <T3>(devices[2].Id);
var fourth = MemoryRegistry.Instance.Get <T4>(devices[3].Id);
var fifth = MemoryRegistry.Instance.Get <T5>(devices[4].Id);
var sixth = MemoryRegistry.Instance.Get <T6>(devices[5].Id);
callback.Invoke(first, second, third, fourth, fifth, sixth);
return(await Task.FromResult <object>(null));
};
_observe.Invoke(queryPayload).Wait();
}
public void Observe <T>(dynamic query, Action <T> callback) where T : Device
{
var queryPayload = new QueryPayload();
queryPayload.Query = query;
queryPayload.Callback = (input) => {
var devices = Serializer.DeserializeArray((string)input, new[] { typeof(IdentityDevice) }, 1).ToArray();
var first = MemoryRegistry.Instance.Get <T>(devices[0].Id);
callback.Invoke(first);
return(Task.FromResult <object>(null));
};
_observe.Invoke(queryPayload).Wait();
}
public async Task <bool> TryResetConnectionAsync(ConnectionSettings cs, IOBehavior ioBehavior, CancellationToken cancellationToken)
{
VerifyState(State.Connected);
try
{
if (ServerVersion.Version.CompareTo(ServerVersions.SupportsResetConnection) >= 0)
{
await SendAsync(ResetConnectionPayload.Create(), ioBehavior, cancellationToken).ConfigureAwait(false);
var payload = await ReceiveReplyAsync(ioBehavior, cancellationToken).ConfigureAwait(false);
OkPayload.Create(payload);
// the "reset connection" packet also resets the connection charset, so we need to change that back to our default
payload = QueryPayload.Create("SET NAMES utf8mb4 COLLATE utf8mb4_bin;");
await SendAsync(payload, ioBehavior, cancellationToken).ConfigureAwait(false);
payload = await ReceiveReplyAsync(ioBehavior, cancellationToken).ConfigureAwait(false);
OkPayload.Create(payload);
}
else
{
// optimistically hash the password with the challenge from the initial handshake (supported by MariaDB; doesn't appear to be supported by MySQL)
var hashedPassword = AuthenticationUtility.CreateAuthenticationResponse(AuthPluginData, 0, cs.Password);
var payload = ChangeUserPayload.Create(cs.UserID, hashedPassword, cs.Database, m_supportsConnectionAttributes ? s_connectionAttributes : null);
await SendAsync(payload, ioBehavior, cancellationToken).ConfigureAwait(false);
payload = await ReceiveReplyAsync(ioBehavior, cancellationToken).ConfigureAwait(false);
if (payload.HeaderByte == AuthenticationMethodSwitchRequestPayload.Signature)
{
payload = await SwitchAuthenticationAsync(cs, payload, ioBehavior, cancellationToken).ConfigureAwait(false);
}
OkPayload.Create(payload);
}
return(true);
}
catch (IOException)
{
}
catch (SocketException)
{
}
return(false);
}
public async Task <IActionResult> ObterTodos([FromQuery] QueryPayload queryPayload)
{
var ambientes = await _ambienteAppService.ObterTodos(_mapper.Map <QueryViewModel>(queryPayload));
var metadata = new
{
ambientes.TotalCount,
ambientes.PageSize,
ambientes.CurrentPage,
ambientes.TotalPages,
ambientes.HasNext,
ambientes.HasPrevious
};
Response.Headers.Add("X-Pagination", JsonConvert.SerializeObject(metadata));
return(Ok(ambientes));
}
public IObservable <T> Observe <T>(dynamic query) where T : Device
{
return(Observable.Create <T>((observer) => {
var queryPayload = new QueryPayload();
queryPayload.Query = query;
queryPayload.Callback = (input) => {
try {
var devices = Serializer.DeserializeArray((string)input, new[] { typeof(IdentityDevice) }, 1).ToArray();
var first = MemoryRegistry.Instance.Get <T>(devices[0].Id);
observer.OnNext(first);
} catch (Exception ex) {
observer.OnError(ex);
}
return Task.FromResult <object>(null);
};
_observe.Invoke(queryPayload).Wait();
return () => { /* handle dispose logic */ };
}));
}
public void FinishQuerying()
{
bool clearConnection = false;
lock (m_lock)
{
if (m_state == State.CancelingQuery)
{
m_state = State.ClearingPendingCancellation;
clearConnection = true;
}
}
if (clearConnection)
{
// KILL QUERY will kill a subsequent query if the command it was intended to cancel has already completed.
// In order to handle this case, we issue a dummy query that will consume the pending cancellation.
// See https://bugs.mysql.com/bug.php?id=45679
var payload = QueryPayload.Create("DO SLEEP(0);");
SendAsync(payload, IOBehavior.Synchronous, CancellationToken.None).GetAwaiter().GetResult();
payload = ReceiveReplyAsync(IOBehavior.Synchronous, CancellationToken.None).GetAwaiter().GetResult();
OkPayload.Create(payload);
}
lock (m_lock)
{
if (m_state == State.Querying || m_state == State.ClearingPendingCancellation)
{
m_state = State.Connected;
}
else
{
VerifyState(State.Failed);
}
m_activeCommandId = 0;
}
}
