public async Task messageBroker_POCO_broadcast_async_should_not_fail()
{
var expected = 4;
var actual = 0;
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<PocoTestMessage>( this, ( s, msg ) =>
{
actual++;
} );
broker.Subscribe<PocoTestMessage>( this, ( s, msg ) =>
{
actual++;
} );
broker.Subscribe<PocoTestMessage>( this, ( s, msg ) =>
{
actual++;
} );
await broker.BroadcastAsync( this, new PocoTestMessage() );
actual++;
Assert.AreEqual( expected, actual );
}
public void Construct(ILogger logger)
{
var sut = new MessageBroker(logger);
Assert.NotNull(sut);
Assert.Equal(logger, sut.Logger);
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
msgBroker = new MessageBroker();
bool isCreatedNew = false;
try
{
_mutex = new Mutex(true, mutexName, out isCreatedNew);
if (isCreatedNew)
{
base.OnStartup(e);
}
else
{
MessageBox.Show("Application already started.", "Error", MessageBoxButton.OK, MessageBoxImage.Information);
Application.Current.Shutdown(0);
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message + "\n\n" + ex.StackTrace + "\n\n" + "Application Existing...", "Exception thrown");
Application.Current.Shutdown(0);
}
}
public void TestBroker()
{
TestMessage message = new TestMessage {Id = Guid.NewGuid(), Text = "Some text"};
MessageBroker broker = new MessageBroker();
broker.Write(message);
TestMessage readMessage = broker.Read<TestMessage>(0);
Assert.IsNotNull(readMessage);
}
public void SubscribeToEventsGrowsSubscriberbase(MessageBroker sut)
{
sut.Subscribe<DummyMessage>(evt => Assert.IsType<DummyMessage>(evt));
Assert.True(sut.Subscriptions[typeof(DummyMessage)].Count() == 1);
sut.Subscribe<DummyMessage>(Assert.NotNull);
Assert.True(sut.Subscriptions[typeof(DummyMessage)].Count() == 2);
}
public void UnsubscribeFromEvent(MessageBroker sut)
{
var subId = sut.Subscribe<DummyMessage>(evt => Assert.IsType<DummyMessage>(evt));
Assert.True(sut.Subscriptions[typeof(DummyMessage)].Any());
sut.Unsubscribe<DummyMessage>(subId);
Assert.False(sut.Subscriptions[typeof(DummyMessage)].Any());
}
private static void StartJob()
{
var messageBroker = new MessageBroker();
var timer = new System.Timers.Timer();
timer.Elapsed += new System.Timers.ElapsedEventHandler(messageBroker.CheckMessages);
timer.Interval = 5000;
timer.Enabled = true;
timer.AutoReset = true;
timer.Start();
}
public void Manager_Should_Call_Created_Event_In_An_Interested_Handler()
{
var mockSysexFirmwareMessageHandler = new Mock<IHandle<object>>();
var manager = new MessageBroker();
manager.Subscribe(mockSysexFirmwareMessageHandler.Object);
manager.CreateEvent(new object());
mockSysexFirmwareMessageHandler.Verify(p => p.Handle(It.IsAny<object>()),Times.Once());
}
public void Broker_Successfully_Unsubscribes_Multiple_IHandle_Class()
{
var broker = new MessageBroker();
var mockTestHandler = new Mock<object>();
mockTestHandler.As<IHandle<object>>();
mockTestHandler.As<IHandle<SysexFirmwareMessage>>();
broker.Subscribe(mockTestHandler.Object);
broker.UnSubscribe(mockTestHandler.Object);
broker.CreateEvent(new object());
broker.CreateEvent(new SysexFirmwareMessage());
mockTestHandler.As<IHandle<object>>().Verify(p => p.Handle(It.IsAny<object>()), Times.Never());
mockTestHandler.As<IHandle<SysexFirmwareMessage>>().Verify(p => p.Handle(It.IsAny<SysexFirmwareMessage>()), Times.Never());
}
public void Publish(MessageBroker sut, string expected)
{
var counter = 0;
var message = new DummyMessage { Identifier = expected };
sut.Subscribe<DummyMessage>(
evt =>
{
Assert.Equal(expected, evt.Identifier);
counter++;
});
sut.Publish(message);
Assert.Equal(1, counter);
}
internal ServiceBase(MessageBroker messageBroker, ServiceDefinition serviceDefinition) {
_messageBroker = messageBroker;
_serviceDefinition = serviceDefinition;
_destinations = new Hashtable();
if (this.ServiceDefinition.Destinations != null) {
foreach (DestinationDefinition destinationDefinition in this.ServiceDefinition.Destinations) {
AdapterDefinition adapterDefinition = null;
AdapterRef adapterRef = destinationDefinition.AdapterRef;
if (adapterRef != null)
adapterDefinition = serviceDefinition.GetAdapterByRef(adapterRef.Ref);
else
adapterDefinition = serviceDefinition.GetDefaultAdapter();
CreateDestination(destinationDefinition, adapterDefinition);
}
}
}
static void Main(string[] args)
{
Console.WriteLine("Gui");
while (true)
{
string input = Console.ReadLine();
int id = 0;
if (int.TryParse(input, out id))
{
MessageBroker broker = new MessageBroker();
broker.Write(new BookingReadyForInvoicing {Id = id});
}
else
{
Console.WriteLine("Done");
Console.ReadKey();
}
}
}
public void messageBroker_unsubscribe_specific_subscriber_should_remove_only_subscriptions_for_that_subscriber()
{
const int expected = 1;
var actual = 0;
var dispatcher = new NullDispatcher();
var target = new MessageBroker( dispatcher );
var subscriber1 = new Object();
var subscriber2 = new Object();
target.Subscribe<LegacyTestMessage>( subscriber1, msg => { actual++; } );
target.Subscribe<LegacyTestMessage>( subscriber1, msg => { actual++; } );
target.Subscribe<LegacyTestMessage>( subscriber1, msg => { actual++; } );
target.Subscribe<LegacyTestMessage>( subscriber2, msg => { actual++; } );
target.Unsubscribe( subscriber1 );
target.Dispatch( new LegacyTestMessage( this ) );
actual.Should().Be.EqualTo( expected );
}
public void Sync()
{
var mb = new MessageBroker();
var l = new List<string>();
var d1 = mb.Subscribe<int>(x => l.Add("a:" + x));
var d2 = mb.Subscribe<int>(x => l.Add("b:" + x));
var d3 = mb.ToObservable<int>().Subscribe(x => l.Add("c:" + x));
mb.Publish(100);
l.Is("a:100", "b:100", "c:100"); l.Clear();
d2.Dispose();
mb.Publish(200);
l.Is("a:200", "c:200"); l.Clear();
d3.Dispose();
mb.Publish(300);
l.Is("a:300"); l.Clear();
d1.Dispose();
mb.Publish(400);
l.Count.Is(0);
}
public void MessageBroker_subscriber_using_a_base_class_should_be_dispatched_using_a_derived_class_message()
{
var actual = false;
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<IMessage>( this, msg => actual = true );
broker.Dispatch( new LegacyTestMessage( this ) );
actual.Should().Be.True();
}
public void messageBroker_MIXED_subscribe_IMessage_normal_should_not_notify_POCO()
{
var expected = false;
var actual = false;
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<IMessage>( this, ( msg ) => actual = true );
broker.Dispatch( this, new PocoTestMessage() );
actual.Should().Be.EqualTo( expected );
}
public void OnModuleLoad(MessageBroker broker)
{
sci.Init(broker);
}
private void ForwardToPowerAdapter(Command command)
{
command.SetProperty(MessageProperties.PinNumber, _PowerAdapterPin);
MessageBroker.Send(command, _PowerAdapterUid);
}
public void messageBroker_POCO_should_broadcast_non_POCO_message_with_correct_Sender()
{
Object expected = this;
Object actual = null;
var h = new ManualResetEvent( false );
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<LegacyTestMessage>( this, msg =>
{
actual = msg.Sender;
h.Set();
} );
broker.Broadcast( this, new LegacyTestMessage() );
h.WaitOne();
Assert.AreEqual( expected, actual );
}
public void messageBroker_POCO_should_dispatch_non_POCO_message_and_subscribe_as_POCO()
{
var received = false;
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<LegacyTestMessage>( this, ( s, msg ) =>
{
received = true;
} );
broker.Dispatch( this, new LegacyTestMessage() );
Assert.IsTrue( received );
}
public JsonRpcExecutive(MessageBroker messageBroker)
: base(messageBroker)
{
}
/// <summary>
/// Основной конструктор, принимающий экземпляр брокера сообщений.
/// </summary>
/// <param name="messageBroker">Брокер сообщений.</param>
public BrokerController(MessageBroker messageBroker)
{
_messageBroker = messageBroker ?? throw new ArgumentNullException(nameof(messageBroker));
}
public override void Invoke(AMFContext context)
{
MessageOutput messageOutput = context.MessageOutput;
for (int i = 0; i < context.AMFMessage.BodyCount; i++)
{
AMFBody amfBody = context.AMFMessage.GetBodyAt(i);
ResponseBody responseBody = null;
//Check for Flex2 messages and skip
if (amfBody.IsEmptyTarget)
{
continue;
}
if (amfBody.IsDebug)
{
continue;
}
if (amfBody.IsDescribeService)
{
responseBody = new ResponseBody();
responseBody.IgnoreResults = amfBody.IgnoreResults;
responseBody.Target = amfBody.Response + AMFBody.OnResult;
responseBody.Response = null;
DescribeService describeService = new DescribeService(amfBody);
responseBody.Content = describeService.GetDescription();
messageOutput.AddBody(responseBody);
continue;
}
//Check if response exists.
responseBody = messageOutput.GetResponse(amfBody);
if (responseBody != null)
{
continue;
}
try
{
MessageBroker messageBroker = _endpoint.GetMessageBroker();
RemotingService remotingService = messageBroker.GetService(RemotingService.RemotingServiceId) as RemotingService;
if (remotingService == null)
{
string serviceNotFound = __Res.GetString(__Res.Service_NotFound, RemotingService.RemotingServiceId);
responseBody = new ErrorResponseBody(amfBody, new FluorineException(serviceNotFound));
messageOutput.AddBody(responseBody);
if (log.IsErrorEnabled)
{
log.Error(serviceNotFound);
}
continue;
}
Destination destination = null;
if (destination == null)
{
destination = remotingService.GetDestinationWithSource(amfBody.TypeName);
}
if (destination == null)
{
destination = remotingService.DefaultDestination;
}
//At this moment we got a destination with the exact source or we have a default destination with the "*" source.
if (destination == null)
{
string destinationNotFound = __Res.GetString(__Res.Destination_NotFound, amfBody.TypeName);
responseBody = new ErrorResponseBody(amfBody, new FluorineException(destinationNotFound));
messageOutput.AddBody(responseBody);
if (log.IsErrorEnabled)
{
log.Error(destinationNotFound);
}
continue;
}
try
{
remotingService.CheckSecurity(destination);
}
catch (UnauthorizedAccessException exception)
{
responseBody = new ErrorResponseBody(amfBody, exception);
if (log.IsDebugEnabled)
{
log.Debug(exception.Message);
}
continue;
}
//Cache check
string source = amfBody.TypeName + "." + amfBody.Method;
IList parameterList = amfBody.GetParameterList();
string key = FluorineFx.Configuration.CacheMap.GenerateCacheKey(source, parameterList);
if (FluorineConfiguration.Instance.CacheMap.ContainsValue(key))
{
object result = FluorineFx.Configuration.FluorineConfiguration.Instance.CacheMap.Get(key);
if (result != null)
{
if (log != null && log.IsDebugEnabled)
{
log.Debug(__Res.GetString(__Res.Cache_HitKey, source, key));
}
responseBody = new ResponseBody(amfBody, result);
messageOutput.AddBody(responseBody);
continue;
}
}
FactoryInstance factoryInstance = destination.GetFactoryInstance();
factoryInstance.Source = amfBody.TypeName;
if (FluorineContext.Current.ActivationMode != null) //query string can override the activation mode
{
factoryInstance.Scope = FluorineContext.Current.ActivationMode;
}
object instance = factoryInstance.Lookup();
if (instance != null)
{
try
{
bool isAccessible = TypeHelper.GetTypeIsAccessible(instance.GetType());
if (!isAccessible)
{
string msg = __Res.GetString(__Res.Type_InitError, amfBody.TypeName);
if (log.IsErrorEnabled)
{
log.Error(msg);
}
responseBody = new ErrorResponseBody(amfBody, new FluorineException(msg));
messageOutput.AddBody(responseBody);
continue;
}
MethodInfo mi = null;
if (!amfBody.IsRecordsetDelivery)
{
mi = MethodHandler.GetMethod(instance.GetType(), amfBody.Method, amfBody.GetParameterList());
}
else
{
//will receive recordsetid only (ignore)
mi = instance.GetType().GetMethod(amfBody.Method);
}
if (mi != null)
{
object[] roleAttributes = mi.GetCustomAttributes(typeof(RoleAttribute), true);
if (roleAttributes != null && roleAttributes.Length == 1)
{
RoleAttribute roleAttribute = roleAttributes[0] as RoleAttribute;
string[] roles = roleAttribute.Roles.Split(',');
bool authorized = messageBroker.LoginManager.DoAuthorization(roles);
if (!authorized)
{
throw new UnauthorizedAccessException(__Res.GetString(__Res.Security_AccessNotAllowed));
}
}
#region Invocation handling
PageSizeAttribute pageSizeAttribute = null;
MethodInfo miCounter = null;
object[] pageSizeAttributes = mi.GetCustomAttributes(typeof(PageSizeAttribute), true);
if (pageSizeAttributes != null && pageSizeAttributes.Length == 1)
{
pageSizeAttribute = pageSizeAttributes[0] as PageSizeAttribute;
miCounter = instance.GetType().GetMethod(amfBody.Method + "Count");
if (miCounter != null && miCounter.ReturnType != typeof(System.Int32))
{
miCounter = null; //check signature
}
}
ParameterInfo[] parameterInfos = mi.GetParameters();
//Try to handle missing/optional parameters.
object[] args = new object[parameterInfos.Length];
if (!amfBody.IsRecordsetDelivery)
{
if (args.Length != parameterList.Count)
{
string msg = __Res.GetString(__Res.Arg_Mismatch, parameterList.Count, mi.Name, args.Length);
if (log != null && log.IsErrorEnabled)
{
log.Error(msg);
}
responseBody = new ErrorResponseBody(amfBody, new ArgumentException(msg));
messageOutput.AddBody(responseBody);
continue;
}
parameterList.CopyTo(args, 0);
if (pageSizeAttribute != null)
{
PagingContext pagingContext = new PagingContext(pageSizeAttribute.Offset, pageSizeAttribute.Limit);
PagingContext.SetPagingContext(pagingContext);
}
}
else
{
if (amfBody.Target.EndsWith(".release"))
{
responseBody = new ResponseBody(amfBody, null);
messageOutput.AddBody(responseBody);
continue;
}
string recordsetId = parameterList[0] as string;
string recordetDeliveryParameters = amfBody.GetRecordsetArgs();
byte[] buffer = System.Convert.FromBase64String(recordetDeliveryParameters);
recordetDeliveryParameters = System.Text.Encoding.UTF8.GetString(buffer);
if (recordetDeliveryParameters != null && recordetDeliveryParameters != string.Empty)
{
string[] stringParameters = recordetDeliveryParameters.Split(new char[] { ',' });
for (int j = 0; j < stringParameters.Length; j++)
{
if (stringParameters[j] == string.Empty)
{
args[j] = null;
}
else
{
args[j] = stringParameters[j];
}
}
//TypeHelper.NarrowValues(argsStore, parameterInfos);
}
PagingContext pagingContext = new PagingContext(System.Convert.ToInt32(parameterList[1]), System.Convert.ToInt32(parameterList[2]));
PagingContext.SetPagingContext(pagingContext);
}
TypeHelper.NarrowValues(args, parameterInfos);
try
{
InvocationHandler invocationHandler = new InvocationHandler(mi);
object result = invocationHandler.Invoke(instance, args);
if (FluorineConfiguration.Instance.CacheMap != null && FluorineConfiguration.Instance.CacheMap.ContainsCacheDescriptor(source))
{
//The result should be cached
CacheableObject cacheableObject = new CacheableObject(source, key, result);
FluorineConfiguration.Instance.CacheMap.Add(cacheableObject.Source, cacheableObject.CacheKey, cacheableObject);
result = cacheableObject;
}
responseBody = new ResponseBody(amfBody, result);
if (pageSizeAttribute != null)
{
int totalCount = 0;
string recordsetId = null;
IList list = amfBody.GetParameterList();
string recordetDeliveryParameters = null;
if (!amfBody.IsRecordsetDelivery)
{
//fist call paging
object[] argsStore = new object[list.Count];
list.CopyTo(argsStore, 0);
recordsetId = System.Guid.NewGuid().ToString();
if (miCounter != null)
{
//object[] counterArgs = new object[0];
totalCount = (int)miCounter.Invoke(instance, args);
}
string[] stringParameters = new string[argsStore.Length];
for (int j = 0; j < argsStore.Length; j++)
{
if (argsStore[j] != null)
{
stringParameters[j] = argsStore[j].ToString();
}
else
{
stringParameters[j] = string.Empty;
}
}
recordetDeliveryParameters = string.Join(",", stringParameters);
byte[] buffer = System.Text.Encoding.UTF8.GetBytes(recordetDeliveryParameters);
recordetDeliveryParameters = System.Convert.ToBase64String(buffer);
}
else
{
recordsetId = amfBody.GetParameterList()[0] as string;
}
if (result is DataTable)
{
DataTable dataTable = result as DataTable;
dataTable.ExtendedProperties["TotalCount"] = totalCount;
dataTable.ExtendedProperties["Service"] = recordetDeliveryParameters + "/" + amfBody.Target;
dataTable.ExtendedProperties["RecordsetId"] = recordsetId;
if (amfBody.IsRecordsetDelivery)
{
dataTable.ExtendedProperties["Cursor"] = Convert.ToInt32(list[list.Count - 2]);
dataTable.ExtendedProperties["DynamicPage"] = true;
}
}
}
}
catch (UnauthorizedAccessException exception)
{
responseBody = new ErrorResponseBody(amfBody, exception);
if (log.IsDebugEnabled)
{
log.Debug(exception.Message);
}
}
catch (Exception exception)
{
if (exception is TargetInvocationException && exception.InnerException != null)
{
responseBody = new ErrorResponseBody(amfBody, exception.InnerException);
}
else
{
responseBody = new ErrorResponseBody(amfBody, exception);
}
if (log.IsDebugEnabled)
{
log.Debug(__Res.GetString(__Res.Invocation_Failed, mi.Name, exception.Message));
}
}
#endregion Invocation handling
}
else
{
responseBody = new ErrorResponseBody(amfBody, new MissingMethodException(amfBody.TypeName, amfBody.Method));
}
}
finally
{
factoryInstance.OnOperationComplete(instance);
}
}
else
{
responseBody = new ErrorResponseBody(amfBody, new TypeInitializationException(amfBody.TypeName, null));
}
}
catch (Exception exception)
{
if (log != null && log.IsErrorEnabled)
{
log.Error(exception.Message, exception);
}
responseBody = new ErrorResponseBody(amfBody, exception);
}
messageOutput.AddBody(responseBody);
}
}
public override void Invoke(AMFContext context)
{
MessageBroker messageBroker = _endpoint.GetMessageBroker();
try
{
AMFHeader amfHeader = context.AMFMessage.GetHeader(AMFHeader.CredentialsHeader);
if (amfHeader != null && amfHeader.Content != null)
{
string userId = ((ASObject)amfHeader.Content)["userid"] as string;
string password = ((ASObject)amfHeader.Content)["password"] as string;
//Clear credentials header, further requests will not send the credentials
ASObject asoObject = new ASObject();
asoObject["name"] = AMFHeader.CredentialsHeader;
asoObject["mustUnderstand"] = false;
asoObject["data"] = null;//clear
AMFHeader header = new AMFHeader(AMFHeader.RequestPersistentHeader, true, asoObject);
context.MessageOutput.AddHeader(header);
IPrincipal principal = _endpoint.GetMessageBroker().LoginManager.Login(userId, amfHeader.Content as IDictionary);
string key = EncryptCredentials(_endpoint, principal, userId, password);
ASObject asoObjectCredentialsId = new ASObject();
asoObjectCredentialsId["name"] = AMFHeader.CredentialsIdHeader;
asoObjectCredentialsId["mustUnderstand"] = false;
asoObjectCredentialsId["data"] = key;//set
AMFHeader headerCredentialsId = new AMFHeader(AMFHeader.RequestPersistentHeader, true, asoObjectCredentialsId);
context.MessageOutput.AddHeader(headerCredentialsId);
}
else
{
amfHeader = context.AMFMessage.GetHeader(AMFHeader.CredentialsIdHeader);
if (amfHeader != null)
{
string key = amfHeader.Content as string;
if (key != null)
{
_endpoint.GetMessageBroker().LoginManager.RestorePrincipal(key);
}
}
else
{
_endpoint.GetMessageBroker().LoginManager.RestorePrincipal();
}
}
}
catch (UnauthorizedAccessException exception)
{
for (int i = 0; i < context.AMFMessage.BodyCount; i++)
{
AMFBody amfBody = context.AMFMessage.GetBodyAt(i);
ErrorResponseBody errorResponseBody = new ErrorResponseBody(amfBody, exception);
context.MessageOutput.AddBody(errorResponseBody);
}
}
catch (Exception exception)
{
if (log != null && log.IsErrorEnabled)
{
log.Error(exception.Message, exception);
}
for (int i = 0; i < context.AMFMessage.BodyCount; i++)
{
AMFBody amfBody = context.AMFMessage.GetBodyAt(i);
ErrorResponseBody errorResponseBody = new ErrorResponseBody(amfBody, exception);
context.MessageOutput.AddBody(errorResponseBody);
}
}
}
public void Empty()
{
var queue = new MessageBroker <object>();
Assert.IsFalse(queue.TryReceive(out var _));
}
public AMFEndpoint(MessageBroker messageBroker, ChannelSettings channelSettings) : base(messageBroker, channelSettings)
{
_waitingPollRequests = new AtomicInteger();
}
private Task OnPinChanged(PinChanged value)
{
return(MessageBroker.Publish(PinValueChangedEvent.Create(Uid, value.PinNumber, value.IsRising)));
}
public void MessageBroker_MIXED_subscriber_using_a_base_class_should_be_dispatched_using_a_derived_class_message_even_using_different_messages()
{
var actual = 0;
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<Object>( this, ( s, msg ) => actual++ );
broker.Dispatch( this, new PocoTestMessage() );
broker.Dispatch( new LegacyAnotherTestMessage( this ) );
actual.Should().Be.EqualTo( 2 );
}
public void MessageBroker_POCO_subscriber_using_a_base_class_should_be_dispatched_only_to_the_expected_inheritance_chain()
{
var actual = 0;
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<PocoTestMessage>( this, ( s, m ) => actual++ );
broker.Dispatch( this, new PocoMessageDerivedFromTestMessage() );
broker.Dispatch( this, new AnotherPocoTestMessage() );
actual.Should().Be.EqualTo( 1 );
}
public override void Invoke(AMFContext context)
{
MessageOutput messageOutput = context.MessageOutput;
for (int i = 0; i < context.AMFMessage.BodyCount; i++)
{
AMFBody amfBody = context.AMFMessage.GetBodyAt(i);
ResponseBody responseBody = null;
//Check for Flex2 messages and skip
if (amfBody.IsEmptyTarget)
{
continue;
}
//Check if response exists.
responseBody = messageOutput.GetResponse(amfBody);
if (responseBody != null)
{
continue;
}
try
{
MessageBroker messageBroker = _endpoint.GetMessageBroker();
RemotingService remotingService = messageBroker.GetService(RemotingService.RemotingServiceId) as RemotingService;
if (remotingService == null)
{
string serviceNotFound = __Res.GetString(__Res.Service_NotFound, RemotingService.RemotingServiceId);
responseBody = new ErrorResponseBody(amfBody, new AMFException(serviceNotFound));
messageOutput.AddBody(responseBody);
continue;
}
Destination destination = null;
if (destination == null)
{
destination = remotingService.GetDestinationWithSource(amfBody.TypeName);
}
if (destination == null)
{
destination = remotingService.DefaultDestination;
}
//At this moment we got a destination with the exact source or we have a default destination with the "*" source.
if (destination == null)
{
string destinationNotFound = __Res.GetString(__Res.Destination_NotFound, amfBody.TypeName);
responseBody = new ErrorResponseBody(amfBody, new AMFException(destinationNotFound));
messageOutput.AddBody(responseBody);
continue;
}
//Cache check
string source = amfBody.TypeName + "." + amfBody.Method;
IList parameterList = amfBody.GetParameterList();
FactoryInstance factoryInstance = destination.GetFactoryInstance();
factoryInstance.Source = amfBody.TypeName;
object instance = factoryInstance.Lookup();
if (instance != null)
{
bool isAccessible = TypeHelper.GetTypeIsAccessible(instance.GetType());
if (!isAccessible)
{
string msg = __Res.GetString(__Res.Type_InitError, amfBody.TypeName);
responseBody = new ErrorResponseBody(amfBody, new AMFException(msg));
messageOutput.AddBody(responseBody);
continue;
}
MethodInfo mi = null;
if (!amfBody.IsRecordsetDelivery)
{
mi = MethodHandler.GetMethod(instance.GetType(), amfBody.Method, amfBody.GetParameterList());
}
else
{
//will receive recordsetid only (ignore)
mi = instance.GetType().GetMethod(amfBody.Method);
}
if (mi != null)
{
#region Invocation handling
ParameterInfo[] parameterInfos = mi.GetParameters();
//Try to handle missing/optional parameters.
object[] args = new object[parameterInfos.Length];
if (!amfBody.IsRecordsetDelivery)
{
if (args.Length != parameterList.Count)
{
string msg = __Res.GetString(__Res.Arg_Mismatch, parameterList.Count, mi.Name, args.Length);
responseBody = new ErrorResponseBody(amfBody, new ArgumentException(msg));
messageOutput.AddBody(responseBody);
continue;
}
parameterList.CopyTo(args, 0);
}
else
{
if (amfBody.Target.EndsWith(".release"))
{
responseBody = new ResponseBody(amfBody, null);
messageOutput.AddBody(responseBody);
continue;
}
string recordsetId = parameterList[0] as string;
string recordetDeliveryParameters = amfBody.GetRecordsetArgs();
byte[] buffer = System.Convert.FromBase64String(recordetDeliveryParameters);
recordetDeliveryParameters = System.Text.Encoding.UTF8.GetString(buffer);
if (recordetDeliveryParameters != null && recordetDeliveryParameters != string.Empty)
{
string[] stringParameters = recordetDeliveryParameters.Split(new char[] { ',' });
for (int j = 0; j < stringParameters.Length; j++)
{
if (stringParameters[j] == string.Empty)
{
args[j] = null;
}
else
{
args[j] = stringParameters[j];
}
}
//TypeHelper.NarrowValues(argsStore, parameterInfos);
}
}
TypeHelper.NarrowValues(args, parameterInfos);
try
{
InvocationHandler invocationHandler = new InvocationHandler(mi);
object result = invocationHandler.Invoke(instance, args);
responseBody = new ResponseBody(amfBody, result);
}
catch (UnauthorizedAccessException exception)
{
responseBody = new ErrorResponseBody(amfBody, exception);
}
catch (Exception exception)
{
if (exception is TargetInvocationException && exception.InnerException != null)
{
responseBody = new ErrorResponseBody(amfBody, exception.InnerException);
}
else
{
responseBody = new ErrorResponseBody(amfBody, exception);
}
}
#endregion Invocation handling
}
else
{
responseBody = new ErrorResponseBody(amfBody, new MissingMethodException(amfBody.TypeName, amfBody.Method));
}
}
else
{
responseBody = new ErrorResponseBody(amfBody, new TypeInitializationException(amfBody.TypeName, null));
}
}
catch (Exception exception)
{
responseBody = new ErrorResponseBody(amfBody, exception);
}
messageOutput.AddBody(responseBody);
}
}
/// <summary>
/// Initializes a new instance of the MessageService class.
/// </summary>
/// <param name="messageBroker"></param>
/// <param name="serviceDefinition"></param>
public MessageService(MessageBroker messageBroker, ServiceDefinition serviceDefinition)
: base(messageBroker, serviceDefinition)
{
}
public SecureAmfEndpoint(MessageBroker messageBroker, ChannelDefinition channelDefinition)
: base(messageBroker, channelDefinition)
{
}
public void AddComponent(IComponent component)
{
_components.Add(component.GetType(), component);
MessageBroker.Publish(new ComponentAddedEvent(this, component));
}
/// <summary>
/// Initializes a new instance of the MessageService class.
/// </summary>
/// <param name="messageBroker"></param>
/// <param name="serviceDefinition"></param>
public MessageService(MessageBroker messageBroker, ServiceDefinition serviceDefinition)
: base(messageBroker, serviceDefinition)
{
}
protected JsonRpcServiceFeature(MessageBroker messageBroker)
{
_messageBroker = messageBroker;
}
public UserController(IUserRepository userRepository, IHttpContextAccessor accesor, MessageBroker messageBroker)
{
_userRepository = userRepository;
_accesor = accesor;
_messageBroker = messageBroker;
}
public RtmptEndpoint(MessageBroker messageBroker, ChannelDefinition channelDefinition)
: base(messageBroker, channelDefinition)
{
}
public void SubscribeToEvents(MessageBroker sut)
{
sut.Subscribe <DummyMessage>(evt => Assert.IsType <DummyMessage>(evt));
Assert.True(sut.Subscriptions[typeof(DummyMessage)].Any());
}
public void LogSubscriptions(MessageBroker sut)
{
sut.Subscribe <DummyMessage>(Assert.NotNull);
sut.Logger.Verify(l => l.Debug(It.IsAny <string>(), It.IsAny <object[]>()));
}
public void ThrowWithNullSubscriptionAction(MessageBroker sut)
{
Assert.Throws <ArgumentNullException>(() => sut.Subscribe <DummyMessage>(null));
}
protected override void OnInvoke(RtmpConnection connection, RtmpChannel channel, RtmpHeader header, Notify invoke)
{
IServiceCall serviceCall = invoke.ServiceCall;
// If it's a callback for server remote call then pass it over to callbacks handler
// and return
if (serviceCall.ServiceMethodName.Equals("_result") || serviceCall.ServiceMethodName.Equals("_error"))
{
HandlePendingCallResult(connection, invoke);
return;
}
bool disconnectOnReturn = false;
string action = null;
if (serviceCall.ServiceName == null)
{
action = serviceCall.ServiceMethodName;
switch (action)
{
case ACTION_CONNECT:
{
if (!connection.IsConnected)
{
IDictionary parameters = invoke.ConnectionParameters;
string host = null;
if (parameters.Contains("tcUrl"))
{
host = GetHostname(parameters["tcUrl"] as string);
}
if (host != null && host.IndexOf(":") != -1)
{
// Remove default port from connection string
host = host.Substring(0, host.IndexOf(":"));
}
string app = parameters["app"] as string;
string path = parameters["app"] as string;
// App name as path, but without query string if there is one
if (path != null && path.IndexOf("?") != -1)
{
int idx = path.IndexOf("?");
parameters["queryString"] = path.Substring(idx);
path = path.Substring(0, idx);
}
parameters["path"] = path;
connection.Setup(host, path, parameters);
try
{
//IGlobalScope global = this.Endpoint.LookupGlobal(host, path);
IGlobalScope global = this.Endpoint.GetMessageBroker().GlobalScope;
if (global == null)
{
serviceCall.Status = Call.STATUS_SERVICE_NOT_FOUND;
if (serviceCall is IPendingServiceCall)
{
StatusASO status = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_INVALID_APPLICATION, connection.ObjectEncoding);
status.description = "No global scope on this server.";
(serviceCall as IPendingServiceCall).Result = status;
}
log.Info(string.Format("No application scope found for {0} on host {1}. Misspelled or missing application folder?", path, host));
disconnectOnReturn = true;
}
else
{
IScopeContext context = global.Context;
IScope scope = null;
try
{
scope = context.ResolveScope(global, path);
}
catch (ScopeNotFoundException /*exception*/)
{
if (log.IsErrorEnabled)
{
log.Error(__Res.GetString(__Res.Scope_NotFound, path));
}
serviceCall.Status = Call.STATUS_SERVICE_NOT_FOUND;
if (serviceCall is IPendingServiceCall)
{
StatusASO status = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_REJECTED, connection.ObjectEncoding);
status.description = "No scope \"" + path + "\" on this server.";
(serviceCall as IPendingServiceCall).Result = status;
}
disconnectOnReturn = true;
}
catch (ScopeShuttingDownException)
{
serviceCall.Status = Call.STATUS_APP_SHUTTING_DOWN;
if (serviceCall is IPendingServiceCall)
{
StatusASO status = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_APPSHUTDOWN, connection.ObjectEncoding);
status.description = "Application at \"" + path + "\" is currently shutting down.";
(serviceCall as IPendingServiceCall).Result = status;
}
log.Info(string.Format("Application at {0} currently shutting down on {1}", path, host));
disconnectOnReturn = true;
}
if (scope != null)
{
if (log.IsInfoEnabled)
{
log.Info(__Res.GetString(__Res.Scope_Connect, scope.Name));
}
bool okayToConnect;
try
{
//The only way to differentiate NetConnection.connect() and Consumer.subscribe() seems to be the app name
if (app == string.Empty)
{
connection.SetIsFlexClient(true);
okayToConnect = connection.Connect(scope, serviceCall.Arguments);
if (okayToConnect)
{
if (serviceCall.Arguments != null && serviceCall.Arguments.Length >= 3)
{
string credentials = serviceCall.Arguments[2] as string;
if (credentials != null && credentials != string.Empty)
{
MessageBroker messageBroker = this.Endpoint.GetMessageBroker();
AuthenticationService authenticationService = messageBroker.GetService(AuthenticationService.ServiceId) as AuthenticationService;
authenticationService.Authenticate(credentials);
}
}
//FDS 2.0.1 fds.swc
if (serviceCall.Arguments != null && serviceCall.Arguments.Length == 1)
{
string credentials = serviceCall.Arguments[0] as string;
if (credentials != null && credentials != string.Empty)
{
MessageBroker messageBroker = this.Endpoint.GetMessageBroker();
AuthenticationService authenticationService = messageBroker.GetService(AuthenticationService.ServiceId) as AuthenticationService;
authenticationService.Authenticate(credentials);
}
}
}
}
else
{
connection.SetIsFlexClient(false);
okayToConnect = connection.Connect(scope, serviceCall.Arguments);
}
if (okayToConnect)
{
if (log.IsDebugEnabled)
{
log.Debug("Connected RtmpClient: " + connection.Client.Id);
}
serviceCall.Status = Call.STATUS_SUCCESS_RESULT;
if (serviceCall is IPendingServiceCall)
{
StatusASO statusASO = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_SUCCESS, connection.ObjectEncoding);
statusASO.Add("id", connection.Client.Id);
(serviceCall as IPendingServiceCall).Result = statusASO;
}
// Measure initial roundtrip time after connecting
connection.GetChannel((byte)2).Write(new Ping(Ping.StreamBegin, 0, -1));
connection.StartRoundTripMeasurement();
}
else
{
if (log.IsDebugEnabled)
{
log.Debug("Connect failed");
}
serviceCall.Status = Call.STATUS_ACCESS_DENIED;
if (serviceCall is IPendingServiceCall)
{
(serviceCall as IPendingServiceCall).Result = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_REJECTED, connection.ObjectEncoding);
}
disconnectOnReturn = true;
}
}
catch (ClientRejectedException rejected)
{
if (log.IsDebugEnabled)
{
log.Debug("Connect rejected");
}
serviceCall.Status = Call.STATUS_ACCESS_DENIED;
if (serviceCall is IPendingServiceCall)
{
StatusASO statusASO = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_REJECTED, connection.ObjectEncoding);
statusASO.Application = rejected.Reason;
(serviceCall as IPendingServiceCall).Result = statusASO;
}
disconnectOnReturn = true;
}
}
}
}
catch (Exception ex)
{
if (log.IsErrorEnabled)
{
log.Error("Error connecting", ex);
}
serviceCall.Status = Call.STATUS_GENERAL_EXCEPTION;
if (serviceCall is IPendingServiceCall)
{
(serviceCall as IPendingServiceCall).Result = StatusASO.GetStatusObject(StatusASO.NC_CONNECT_FAILED, connection.ObjectEncoding);
}
disconnectOnReturn = true;
}
}
else
{
// Service calls, must be connected.
InvokeCall(connection, serviceCall);
}
}
break;
case ACTION_DISCONNECT:
connection.Close();
break;
case ACTION_CREATE_STREAM:
case ACTION_DELETE_STREAM:
case ACTION_RELEASE_STREAM:
case ACTION_PUBLISH:
case ACTION_PLAY:
case ACTION_SEEK:
case ACTION_PAUSE:
case ACTION_CLOSE_STREAM:
case ACTION_RECEIVE_VIDEO:
case ACTION_RECEIVE_AUDIO:
{
IStreamService streamService = ScopeUtils.GetScopeService(connection.Scope, typeof(IStreamService)) as IStreamService;
StatusASO status = null;
try
{
if (!InvokeCall(connection, serviceCall, streamService))
{
status = StatusASO.GetStatusObject(StatusASO.NS_INVALID_ARGUMENT, connection.ObjectEncoding);
status.description = "Failed to " + action + " (stream ID: " + header.StreamId + ")";
}
}
catch (Exception ex)
{
log.Error("Error while invoking " + action + " on stream service.", ex);
status = StatusASO.GetStatusObject(StatusASO.NS_FAILED, connection.ObjectEncoding);
status.description = "Error while invoking " + action + " (stream ID: " + header.StreamId + ")";
status.details = ex.Message;
}
if (status != null)
{
channel.SendStatus(status);
}
}
break;
default:
if (connection.IsConnected)
{
InvokeCall(connection, serviceCall);
}
else
{
// Warn user attemps to call service without being connected
if (log.IsWarnEnabled)
{
log.Warn("Not connected, closing connection");
}
connection.Close();
}
break;
}
}
/*
* if(invoke is FlexInvoke)
* {
* FlexInvoke reply = new FlexInvoke();
* reply.InvokeId = invoke.InvokeId;
* reply.SetResponseSuccess();
* //TODO
* if( serviceCall is IPendingServiceCall )
* {
* IPendingServiceCall pendingCall = (IPendingServiceCall)serviceCall;
* reply.Response = pendingCall.Result;
* }
* channel.Write(reply);
* }
* else if(invoke is Invoke)
*/
if (invoke is Invoke)
{
if ((header.StreamId != 0) &&
(serviceCall.Status == Call.STATUS_SUCCESS_VOID || serviceCall.Status == Call.STATUS_SUCCESS_NULL))
{
if (log.IsDebugEnabled)
{
log.Debug("Method does not have return value, do not reply");
}
return;
}
// The client expects a result for the method call.
Invoke reply = new Invoke();
reply.ServiceCall = serviceCall;
reply.InvokeId = invoke.InvokeId;
//sending reply
channel.Write(reply);
}
if (disconnectOnReturn)
{
connection.Close();
}
if (action == ACTION_CONNECT)
{
connection.Context.ObjectEncoding = connection.ObjectEncoding;
}
}
public StudentController(IStudentRepository studentRepository, MessageBroker messageBroker)
{
_studentRepository = studentRepository;
_messageBroker = messageBroker;
}
public void messageBroker_POCO_broadcast_using_more_then_one_subscriber_should_call_on_different_thread()
{
TestRunner.Execute( ApartmentState.MTA, () =>
{
var h1 = new ManualResetEvent( false );
var h2 = new ManualResetEvent( false );
var currentThreadId = Thread.CurrentThread.ManagedThreadId;
var s1ThreadId = Thread.CurrentThread.ManagedThreadId;
var s2ThreadId = Thread.CurrentThread.ManagedThreadId;
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<PocoTestMessage>( this, ( s, msg ) =>
{
s1ThreadId = Thread.CurrentThread.ManagedThreadId;
h1.Set();
} );
broker.Subscribe<PocoTestMessage>( this, ( s, msg ) =>
{
s2ThreadId = Thread.CurrentThread.ManagedThreadId;
h2.Set();
} );
broker.Broadcast( this, new PocoTestMessage() );
ManualResetEvent.WaitAll( new[] { h1, h2 } );
currentThreadId.Should().Not.Be.EqualTo( s1ThreadId );
currentThreadId.Should().Not.Be.EqualTo( s2ThreadId );
} );
}
public AMFEndpoint(MessageBroker messageBroker, ChannelDefinition channelDefinition)
: base(messageBroker, channelDefinition)
{
_waitingPollRequests = new AtomicInteger();
}
public void MessageBroker_POCO_subscriber_using_a_base_class_should_be_dispatched_using_a_derived_class_message()
{
var actual = false;
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<Object>( this, ( s, msg ) => actual = true );
broker.Dispatch( this, new PocoTestMessage() );
actual.Should().Be.True();
}
/// <summary>
/// Logs out the current user.
/// </summary>
/// <returns><c>true</c> if logging out succeeded; otherwise, <c>false</c>.</returns>
public bool Logout()
{
MessageBroker messageBroker = MessageBroker.GetMessageBroker(MessageBroker.DefaultMessageBrokerId);
return(messageBroker.LoginManager.Logout());
}
public void MessageBroker_subscriber_using_a_base_class_should_be_dispatched_only_to_the_expected_inheritance_chain()
{
var actual = 0;
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<LegacyTestMessage>( this, msg => actual++ );
broker.Dispatch( new LegacyMessageDerivedFromLegacyTestMessage( this ) );
broker.Dispatch( new LegacyAnotherTestMessage( this ) );
actual.Should().Be.EqualTo( 1 );
}
public void Send_Successful()
{
MessageBroker.Send(new Message <Cat>(MessageCommand.Create, new Cat()));
QueueClientMock.VerifySend();
}
public void messageBroker_broadcast_should_report_expected_exception()
{
ManualResetEvent h = new ManualResetEvent( false );
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<LegacyTestMessage>( this, msg =>
{
throw new ArgumentException();
} );
try
{
broker.Broadcast( new LegacyTestMessage( this ) );
h.WaitOne();
}
catch
{
h.Set();
throw;
}
}
public EndpointBase(MessageBroker messageBroker, ChannelDefinition channelDefinition)
{
_messageBroker = messageBroker;
_channelDefinition = channelDefinition;
}
public void messageBroker_POCO_should_broadcast_non_POCO_message_and_subscribe_as_POCO()
{
var received = false;
var h = new ManualResetEvent( false );
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<LegacyTestMessage>( this, ( s, msg ) =>
{
received = true;
h.Set();
} );
broker.Broadcast( this, new LegacyTestMessage() );
h.WaitOne();
Assert.IsTrue( received );
}
public StreamingAmfEndpoint(MessageBroker messageBroker, ChannelDefinition channelDefinition)
: base(messageBroker, channelDefinition)
{
_streamingClientsCount = new AtomicInteger();
}
public void messageBroker_POCO_should_dispatch_non_POCO_message_with_correct_Sender()
{
Object expected = this;
Object actual = null;
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
broker.Subscribe<LegacyTestMessage>( this, msg =>
{
actual = msg.Sender;
} );
broker.Dispatch( this, new LegacyTestMessage() );
Assert.AreEqual( expected, actual );
}
public MessageService(MessageBroker messageBroker, ServiceSettings serviceSettings) : base(messageBroker, serviceSettings)
{
}
public void MessageBroker_broadcast_from_multiple_thread_should_not_fail()
{
Exception failure = null;
var wh = new ManualResetEvent( false );
var run = true;
var dispatcher = new NullDispatcher();
var broker = new MessageBroker( dispatcher );
// do some metrics to find a good number of subscription to let the pub do a long running
const int metricsCount = 100;
for( int i = 0; i < metricsCount; i++ )
{
broker.Subscribe<PocoTestMessage>( this, ( sender, msg ) => { } );
}
var sw = Stopwatch.StartNew();
broker.Broadcast(this, new PocoTestMessage());
sw.Stop();
const int longRunningTiming = 100;
var elapsedMilliseconds = sw.ElapsedMilliseconds == 0
? longRunningTiming
: sw.ElapsedMilliseconds;
var subCountForLongRunning = (longRunningTiming / elapsedMilliseconds) * metricsCount;
Trace.WriteLine(string.Format("Need {0} subscriptions to run for at least {1} ms. {2} took {3} ms.", subCountForLongRunning, longRunningTiming, metricsCount, sw.ElapsedMilliseconds));
for (int i = 0; i < subCountForLongRunning - metricsCount; i++)
{
broker.Subscribe<PocoTestMessage>(this, (sender, msg) => { });
}
// this will take approximately 100 ms to do 1 broadcast
var broadcastThread1 = new Thread( payload =>
{
while( run )
{
try
{
broker.Broadcast( this, new PocoTestMessage() );
}
catch( Exception e )
{
lock( this )
{
failure = e;
wh.Set();
}
break;
}
}
} );
broadcastThread1.IsBackground = true;
broadcastThread1.Start();
// this should istantly throw an error because the broadcasting is enumerating the subscriptions and should take 100 ms to enumerate them all
var subscriberThread1 = new Thread(payload =>
{
while (run)
{
try
{
broker.Subscribe<PocoTestMessage>(this, (sender, msg) =>
{
Thread.Sleep(10);
});
}
catch (Exception e)
{
lock (this)
{
failure = e;
wh.Set();
break;
}
}
}
});
subscriberThread1.IsBackground = true;
subscriberThread1.Start();
var timeout = 1;
var signaled = wh.WaitOne( TimeSpan.FromSeconds( timeout ) );
if( !signaled )
{
Trace.WriteLine( String.Format( "Run without any issue for {0} seconds.", timeout ) );
}
run = false;
subscriberThread1.Join();
Assert.IsNull( failure, failure != null ? failure.ToString() : "--" );
}
public RtmptEndpoint(MessageBroker messageBroker, ChannelSettings channelSettings) : base(messageBroker, channelSettings)
{
}
public void SetUp()
{
broker = new MessageBroker();
}
public HomeController(IPhoneRepository phoneRepository, IHostingEnvironment hostingEnvironment, MessageBroker broker)
{
_phoneRepository = phoneRepository;
this.hostingEnvironment = hostingEnvironment;
_broker = broker;
}
public SecureAmfEndpoint(MessageBroker messageBroker, ChannelDefinition channelDefinition)
: base(messageBroker, channelDefinition)
{
}
public RemotingService(MessageBroker broker, ServiceSettings settings) : base(broker, settings)
{
}
