public void QueueEvents(RemoteEvent remoteEvent)
{
try
{
if (_eventManager == null)
{
ConnectionRequest(out var auxHandle, out var ipAddress, out var portNumber);
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber);
var dummy = _eventManager.WaitForEventsAsync(remoteEvent);
}
remoteEvent.LocalId++;
var epb = remoteEvent.BuildEpb();
var epbData = epb.ToArray();
Xdr.Write(IscCodes.op_que_events);
Xdr.Write(_handle);
Xdr.WriteBuffer(epbData);
Xdr.Write(AddressOfAstRoutine);
Xdr.Write(ArgumentToAstRoutine);
Xdr.Write(remoteEvent.LocalId);
Xdr.Flush();
var response = (GenericResponse)ReadResponse();
remoteEvent.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public void QueueEvents(RemoteEvent remoteEvent)
{
lock (this)
{
lock (this.events.SyncRoot)
{
if (!this.events.ContainsKey(remoteEvent.LocalId))
{
this.events.Add(remoteEvent.LocalId, remoteEvent);
}
}
#if (!NETCF)
if (this.thread == null ||
(this.thread.ThreadState != ThreadState.Running && this.thread.ThreadState != ThreadState.Background))
#else
if (this.thread == null)
#endif
{
this.thread = new Thread(new ThreadStart(ThreadHandler));
this.thread.Start();
this.thread.IsBackground = true;
}
}
}
public void QueueEvents(RemoteEvent remoteEvent)
{
lock (this)
{
if (!this.events.ContainsKey(remoteEvent.LocalId))
{
lock (this.events.SyncRoot)
{
this.events.Add(remoteEvent.LocalId, remoteEvent);
}
}
#if (!NET_CF)
if (this.eventsThread == null ||
(this.eventsThread.ThreadState != ThreadState.Running &&
this.eventsThread.ThreadState != ThreadState.Background))
#else
if (this.eventsThread == null)
#endif
{
#if (NET_CF)
this.eventsThread = new Thread(new ThreadStart(() => ThreadHandler(this.syncControl)));
#else
this.eventsThread = new Thread(new ThreadStart(() => ThreadHandler(this.syncContext)));
#endif
this.eventsThread.IsBackground = true;
this.eventsThread.Name = "FirebirdClient - Events Thread";
this.eventsThread.Start();
}
}
}
public void CancelEvents(RemoteEvent remoteEvent)
{
lock (this.events.SyncRoot)
{
this.events.Remove(remoteEvent.LocalId);
}
}
public override void QueueEvents(RemoteEvent remoteEvent)
{
try
{
if (_eventManager == null)
{
var(auxHandle, ipAddress, portNumber, timeout) = ConnectionRequest();
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber, timeout);
_eventManager.Open();
var dummy = _eventManager.StartWaitingForEvents(remoteEvent);
}
remoteEvent.LocalId++;
var epb = remoteEvent.BuildEpb();
var epbData = epb.ToArray();
Xdr.Write(IscCodes.op_que_events);
Xdr.Write(_handle);
Xdr.WriteBuffer(epbData);
Xdr.Write(AddressOfAstRoutine);
Xdr.Write(ArgumentToAstRoutine);
Xdr.Write(remoteEvent.LocalId);
Xdr.Flush();
var response = (GenericResponse)ReadResponse();
remoteEvent.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public FbRemoteEvent(string connectionString)
{
_connection = new FbConnectionInternal(new FbConnectionString(connectionString));
_connection.Connect();
_revent = new RemoteEvent(_connection.Database);
_revent.EventCountsCallback = OnRemoteEventCounts;
_revent.EventErrorCallback = OnRemoteEventError;
_synchronizationContext = SynchronizationContext.Current ?? new SynchronizationContext();
}
/// <summary>
/// Adds a remote event.
/// </summary>
/// <param name="eventName">The name of the event to use.</param>
/// <param name="evt">The RemoteEvent delegate method to add.</param>
public void AddRemoteEvent(string eventName, RemoteEvent evt)
{
if (Events.ContainsKey(eventName))
{
throw new InvalidOperationException(String.Format("Event \"{0}\" already exists!", eventName));
}
Events.TryAdd(eventName, evt);
}
private void OnWindowClosed(RemoteEvent obj)
{
var vm = ViewModelMapper.GetViewModel(obj.Payload);
_remoteWindowOperationsBus.Publish(new RemoteWindowOperationEvent()
{
RemoteEvent = obj, ViewModel = vm
}, this);
}
public void AddEventHandler(uint topId, uint bottomId, Func <uint, uint, uint> handler)
{
var remoteEvent = new RemoteEvent()
{
TopId = topId,
BottomId = bottomId,
EventHandler = handler,
};
RemoteEvents.Add(remoteEvent);
}
public void Open()
{
if (_revent != null)
{
throw new InvalidOperationException($"{nameof(FbRemoteEvent)} already open.");
}
_connection.Connect();
_revent = new RemoteEvent(_connection.Database);
_revent.EventCountsCallback = OnRemoteEventCounts;
_revent.EventErrorCallback = OnRemoteEventError;
_synchronizationContext = SynchronizationContext.Current ?? new SynchronizationContext();
}
private async Task OpenImpl(AsyncWrappingCommonArgs async)
{
if (_revent != null)
{
throw new InvalidOperationException($"{nameof(FbRemoteEvent)} already open.");
}
await _connection.Connect(async).ConfigureAwait(false);
_revent = new RemoteEvent(_connection.Database);
_revent.EventCountsCallback = OnRemoteEventCounts;
_revent.EventErrorCallback = OnRemoteEventError;
_synchronizationContext = SynchronizationContext.Current ?? new SynchronizationContext();
}
public byte[] Serialize(RemoteEvent obj)
{
var payload = obj.Payload;
var seri = JsonConvert.SerializeObject(payload, _serializerSettings);
var payloadBa = Encoding.Default.GetBytes(seri);
var rv = new byte[payloadBa.Length + 1];
rv[0] = (byte)obj.Type;
Array.Copy(payloadBa, 0, rv, 1, payloadBa.Length);
return(rv);
}
public async Task OpenAsync(CancellationToken cancellationToken = default)
{
if (_revent != null)
{
throw new InvalidOperationException($"{nameof(FbRemoteEvent)} already open.");
}
await _connection.ConnectAsync(cancellationToken).ConfigureAwait(false);
_revent = new RemoteEvent(_connection.Database);
_revent.EventCountsCallback = OnRemoteEventCounts;
_revent.EventErrorCallback = OnRemoteEventError;
_synchronizationContext = SynchronizationContext.Current ?? new SynchronizationContext();
}
/// <include file='Doc/en_EN/FbRemoteEvent.xml' path='doc/class[@name="FbRemoteEvent"]/constructor[@name="ctor(FbConnection, System.Array)"]/*'/>
public FbRemoteEvent(FbConnection connection, string[] events)
{
if (connection == null || connection.State != System.Data.ConnectionState.Open)
{
throw new InvalidOperationException("Connection must valid and open");
}
this.connection = connection;
this.revent = connection.InnerConnection.Database.CreateEvent();
this.revent.EventCountsCallback = new EventCountsCallback(this.OnRemoteEventCounts);
if (events != null)
{
this.AddEvents(events);
}
}
public RpcClient(ISerializer serializer, TimeSpan rpcTimeout, IThreadDispatcher threadDispatcher)
{
using (EneterTrace.Entering())
{
if (serializer == null)
{
string anError = "Input parameter serializer is null.";
EneterTrace.Error(anError);
throw new ArgumentNullException(anError);
}
mySerializer = serializer;
myRpcTimeout = rpcTimeout;
#if !NETSTANDARD
ServiceInterfaceChecker.CheckForClient <TServiceInterface>();
// Dynamically implement and instantiate the given interface as the proxy.
Proxy = ProxyProvider.CreateInstance <TServiceInterface>(CallMethod, SubscribeEvent, UnsubscribeEvent);
#endif
// Store remote methods.
foreach (MethodInfo aMethodInfo in typeof(TServiceInterface).GetMethods())
{
Type aReturnType = aMethodInfo.ReturnType;
Type[] anArgTypes = aMethodInfo.GetParameters().Select(x => x.ParameterType).ToArray();
RemoteMethod aRemoteMethod = new RemoteMethod(aReturnType, anArgTypes);
myRemoteMethods[aMethodInfo.Name] = aRemoteMethod;
}
// Store remote events.
foreach (EventInfo anEventInfo in typeof(TServiceInterface).GetEvents())
{
if (anEventInfo.EventHandlerType.IsGenericType)
{
RemoteEvent aRemoteEvent = new RemoteEvent(anEventInfo.EventHandlerType.GetGenericArguments()[0]);
myRemoteEvents[anEventInfo.Name] = aRemoteEvent;
}
else
{
RemoteEvent aRemoteEvent = new RemoteEvent(typeof(EventArgs));
myRemoteEvents[anEventInfo.Name] = aRemoteEvent;
}
}
myThreadDispatcher = threadDispatcher;
}
}
public void QueueEvents(RemoteEvent remoteEvent)
{
lock (this)
{
_events[remoteEvent.LocalId] = remoteEvent;
// Jiri Cincura: I'm pretty sure this is a race condition.
if (_eventsThread == null || _eventsThread.ThreadState.HasFlag(ThreadState.Stopped | ThreadState.Unstarted))
{
_eventsThread = new Thread(ThreadHandler);
_eventsThread.IsBackground = true;
_eventsThread.Name = "FirebirdClient - Events Thread";
_eventsThread.Start();
}
}
}
public void CancelEvents(RemoteEvent events)
{
try
{
Xdr.Write(IscCodes.op_cancel_events);
Xdr.Write(_handle);
Xdr.Write(events.LocalId);
Xdr.Flush();
ReadResponse();
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_network_error, ex);
}
}
public FbRemoteEvent(FbConnection connection, params string[] events)
{
if (connection == null || connection.State != System.Data.ConnectionState.Open)
{
throw new InvalidOperationException("Connection must be valid and open");
}
_connection = connection;
_revent = connection.InnerConnection.Database.CreateEvent();
_revent.EventCountsCallback = new RemoteEventCountsCallback(OnRemoteEventCounts);
_synchronizationContext = SynchronizationContext.Current ?? new SynchronizationContext();
if (events != null)
{
AddEvents(events);
}
}
public override void CancelEvents(RemoteEvent events)
{
try
{
Xdr.Write(IscCodes.op_cancel_events);
Xdr.Write(_handle);
Xdr.Write(events.LocalId);
Xdr.Flush();
ReadResponse();
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public void QueueEvents(RemoteEvent events)
{
if (this.eventManager == null)
{
string ipAddress = string.Empty;
int portNumber = 0;
int auxHandle = 0;
this.ConnectionRequest(out auxHandle, out ipAddress, out portNumber);
this.eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber);
}
lock (this.SyncObject)
{
try
{
events.LocalId = ++this.eventsId;
EventParameterBuffer epb = events.ToEpb();
this.Write(IscCodes.op_que_events); // Op codes
this.Write(this.handle); // Database object id
this.WriteBuffer(epb.ToArray()); // Event description block
this.Write(0); // Address of ast routine
this.Write(0); // Argument to ast routine
this.Write(events.LocalId); // Client side id of remote event
this.Flush();
GenericResponse response = (GenericResponse)this.ReadResponse();
// Update event Remote event ID
events.RemoteId = response.ObjectHandle;
// Enqueue events in the event manager
this.eventManager.QueueEvents(events);
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
public void QueueEvents(RemoteEvent events)
{
if (_eventManager == null)
{
string ipAddress = string.Empty;
int portNumber = 0;
int auxHandle = 0;
ConnectionRequest(out auxHandle, out ipAddress, out portNumber);
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber);
}
lock (SyncObject)
{
try
{
events.LocalId = Interlocked.Increment(ref _eventsId);
// Enqueue events in the event manager
_eventManager.QueueEvents(events);
EventParameterBuffer epb = events.ToEpb();
XdrStream.Write(IscCodes.op_que_events);
XdrStream.Write(_handle); // Database object id
XdrStream.WriteBuffer(epb.ToArray()); // Event description block
XdrStream.Write(0); // Address of ast routine
XdrStream.Write(0); // Argument to ast routine
XdrStream.Write(events.LocalId); // Client side id of remote event
XdrStream.Flush();
GenericResponse response = (GenericResponse)ReadResponse();
// Update event Remote event ID
events.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
public override async ValueTask CancelEventsAsync(RemoteEvent events, CancellationToken cancellationToken = default)
{
try
{
await Xdr.WriteAsync(IscCodes.op_cancel_events, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(_handle, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(events.LocalId, cancellationToken).ConfigureAwait(false);
await Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
await ReadResponseAsync(cancellationToken).ConfigureAwait(false);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async Task CancelEvents(RemoteEvent events, AsyncWrappingCommonArgs async)
{
try
{
await Xdr.Write(IscCodes.op_cancel_events, async).ConfigureAwait(false);
await Xdr.Write(_handle, async).ConfigureAwait(false);
await Xdr.Write(events.LocalId, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
await ReadResponse(async).ConfigureAwait(false);
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async Task QueueEvents(RemoteEvent remoteEvent, AsyncWrappingCommonArgs async)
{
try
{
if (_eventManager == null)
{
var(auxHandle, ipAddress, portNumber) = await ConnectionRequest(async).ConfigureAwait(false);
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber);
await _eventManager.Open(async).ConfigureAwait(false);
var dummy = _eventManager.WaitForEvents(remoteEvent, new AsyncWrappingCommonArgs(true));
}
remoteEvent.LocalId++;
var epb = remoteEvent.BuildEpb();
var epbData = epb.ToArray();
await Xdr.Write(IscCodes.op_que_events, async).ConfigureAwait(false);
await Xdr.Write(_handle, async).ConfigureAwait(false);
await Xdr.WriteBuffer(epbData, async).ConfigureAwait(false);
await Xdr.Write(AddressOfAstRoutine, async).ConfigureAwait(false);
await Xdr.Write(ArgumentToAstRoutine, async).ConfigureAwait(false);
await Xdr.Write(remoteEvent.LocalId, async).ConfigureAwait(false);
await Xdr.Flush(async).ConfigureAwait(false);
var response = (GenericResponse) await ReadResponse(async).ConfigureAwait(false);
remoteEvent.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
public override async ValueTask QueueEventsAsync(RemoteEvent remoteEvent, CancellationToken cancellationToken = default)
{
try
{
if (_eventManager == null)
{
var(auxHandle, ipAddress, portNumber, timeout) = await ConnectionRequestAsync(cancellationToken).ConfigureAwait(false);
_eventManager = new GdsEventManager(auxHandle, ipAddress, portNumber, timeout);
await _eventManager.OpenAsync(cancellationToken).ConfigureAwait(false);
var dummy = _eventManager.StartWaitingForEvents(remoteEvent);
}
remoteEvent.LocalId++;
var epb = remoteEvent.BuildEpb();
var epbData = epb.ToArray();
await Xdr.WriteAsync(IscCodes.op_que_events, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(_handle, cancellationToken).ConfigureAwait(false);
await Xdr.WriteBufferAsync(epbData, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(AddressOfAstRoutine, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(ArgumentToAstRoutine, cancellationToken).ConfigureAwait(false);
await Xdr.WriteAsync(remoteEvent.LocalId, cancellationToken).ConfigureAwait(false);
await Xdr.FlushAsync(cancellationToken).ConfigureAwait(false);
var response = (GenericResponse) await ReadResponseAsync(cancellationToken).ConfigureAwait(false);
remoteEvent.RemoteId = response.ObjectHandle;
}
catch (IOException ex)
{
throw IscException.ForIOException(ex);
}
}
// this is a special method that's not awaited
public async Task StartWaitingForEvents(RemoteEvent remoteEvent)
{
while (true)
{
try
{
var operation = await _database.ReadOperationAsync(CancellationToken.None).ConfigureAwait(false);
switch (operation)
{
case IscCodes.op_event:
var dbHandle = await _database.Xdr.ReadInt32Async(CancellationToken.None).ConfigureAwait(false);
var buffer = await _database.Xdr.ReadBufferAsync(CancellationToken.None).ConfigureAwait(false);
var ast = new byte[8];
await _database.Xdr.ReadBytesAsync(ast, 8, CancellationToken.None).ConfigureAwait(false);
var eventId = await _database.Xdr.ReadInt32Async(CancellationToken.None).ConfigureAwait(false);
remoteEvent.EventCounts(buffer);
await remoteEvent.Database.QueueEventsAsync(remoteEvent, CancellationToken.None).ConfigureAwait(false);
break;
default:
Debug.Assert(false);
break;
}
}
catch (Exception) when(Volatile.Read(ref _closing))
{
return;
}
catch (Exception ex)
{
remoteEvent.EventError(ex);
break;
}
}
}
public async Task WaitForEvents(RemoteEvent remoteEvent, AsyncWrappingCommonArgs async)
{
while (true)
{
try
{
var operation = await _database.ReadOperation(async).ConfigureAwait(false);
switch (operation)
{
case IscCodes.op_event:
var dbHandle = await _database.Xdr.ReadInt32(async).ConfigureAwait(false);
var buffer = await _database.Xdr.ReadBuffer(async).ConfigureAwait(false);
var ast = new byte[8];
await _database.Xdr.ReadBytes(ast, 8, async).ConfigureAwait(false);
var eventId = await _database.Xdr.ReadInt32(async).ConfigureAwait(false);
await remoteEvent.EventCounts(buffer, async).ConfigureAwait(false);
break;
default:
Debug.Assert(false);
break;
}
}
catch (Exception) when(Volatile.Read(ref _closing))
{
return;
}
catch (Exception ex)
{
remoteEvent.EventError(ex);
break;
}
}
}
public void CancelEvents(RemoteEvent events)
{
lock (SyncObject)
{
try
{
Write(IscCodes.op_cancel_events);
Write(_handle); // Database object id
Write(events.LocalId); // Event ID
Flush();
ReadResponse();
_eventManager.CancelEvents(events);
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
public void CancelEvents(RemoteEvent events)
{
lock (SyncObject)
{
try
{
XdrStream.Write(IscCodes.op_cancel_events);
XdrStream.Write(_handle); // Database object id
XdrStream.Write(events.LocalId); // Event ID
XdrStream.Flush();
ReadResponse();
_eventManager.CancelEvents(events);
}
catch (IOException ex)
{
throw IscException.ForErrorCode(IscCodes.isc_net_read_err, ex);
}
}
}
public void CancelEvents(RemoteEvent events)
{
lock (this)
{
try
{
this.Send.Write(IscCodes.op_cancel_events); // Op code
this.Send.Write(this.handle); // Database object id
this.Send.Write(events.LocalId); // Event ID
this.Send.Flush();
this.ReadGenericResponse();
this.eventManager.CancelEvents(events);
}
catch (IOException)
{
throw new IscException(IscCodes.isc_net_read_err);
}
}
}
