/// <summary> /// Clients can call this method to commit the transaction. You should only use this method if /// you used the begin method to create the DataServiceTransaction. /// Otherwise, the gateway will commit or rollback the transaction as necessary. /// </summary> public void Commit() { if( _rollbackOnly ) { Rollback(); return; } try { ProcessRefreshFills(); _pushMessages = new ArrayList(); for(int i = 0; i < _processedMessageBatches.Count; i++) { MessageBatch messageBatch = _processedMessageBatches[i] as MessageBatch; if( messageBatch.Messages != null && messageBatch.Messages.Count > 0 ) { DataDestination dataDestination = _dataService.GetDestination(messageBatch.IncomingMessage) as DataDestination; try { dataDestination.SequenceManager.ManageMessageBatch(messageBatch, this); } catch(Exception ex) { MessageException messageException = new MessageException(ex); ErrorMessage errorMessage = messageException.GetErrorMessage(); errorMessage.correlationId = messageBatch.IncomingMessage.messageId; errorMessage.destination = messageBatch.IncomingMessage.destination; messageBatch.Messages.Clear(); messageBatch.Messages.Add(errorMessage); } for(int j = 0; j < messageBatch.Messages.Count; j++) { IMessage message = messageBatch.Messages[j] as IMessage; if( !(message is ErrorMessage) ) _pushMessages.Add(message); } } _outgoingMessages.AddRange(messageBatch.Messages); } for(int i = 0; i < _pushMessages.Count; i++) { IMessage message = _pushMessages[i] as IMessage; DataMessage dataMessage = message as DataMessage; if( dataMessage != null ) PushMessage(GetSubscribers(message), message); } foreach(DictionaryEntry entry in _clientUpdateCollectionMessages) { UpdateCollectionMessage updateCollectionMessage = entry.Value as UpdateCollectionMessage; _outgoingMessages.Add(updateCollectionMessage); PushMessage(GetSubscribers(updateCollectionMessage), updateCollectionMessage); } foreach(DictionaryEntry entry in _updateCollectionMessages) { UpdateCollectionMessage updateCollectionMessage = entry.Value as UpdateCollectionMessage; _outgoingMessages.Add(updateCollectionMessage); PushMessage(GetSubscribers(updateCollectionMessage), updateCollectionMessage); } } finally { _transactionState = TransactionState.Committed; } }
private IList Batch(DataMessage dataMessage) { ArrayList result = new ArrayList(); IList messageBatch = dataMessage.body as IList; for(int i = 0; i < messageBatch.Count; i++) { IMessage message = messageBatch[i] as IMessage; try { if( message is UpdateCollectionMessage ) { result.Add(UpdateCollection(message as UpdateCollectionMessage, messageBatch)); } else { object obj = Invoke(message); result.Add(obj); } } catch(DataSyncException dataSyncException) { DataErrorMessage dataErrorMessage = dataSyncException.GetErrorMessage() as DataErrorMessage; dataErrorMessage.cause = message as DataMessage; dataErrorMessage.correlationId = message.messageId; dataErrorMessage.destination = message.destination; result.Add(dataErrorMessage); } catch(Exception exception) { MessageException messageException = new MessageException(exception); ErrorMessage errorMessage = messageException.GetErrorMessage(); errorMessage.correlationId = message.messageId; errorMessage.destination = message.destination; result.Add(errorMessage); } } return result; }
/// <summary> /// Registers an IEndpointPushHandler for the specified endpoint to handle pushing messages. /// </summary> /// <param name="handler">The IEndpointPushHandler to register.</param> /// <param name="endpointId">The endpoint identity to register for.</param> public void RegisterEndpointPushHandler(IEndpointPushHandler handler, string endpointId) { if (_endpointPushHandlers == null) { lock (this.SyncRoot) { if (_endpointPushHandlers == null) _endpointPushHandlers = new CopyOnWriteDictionary(1); } } if (_endpointPushHandlers.ContainsKey(endpointId)) { MessageException me = new MessageException(); me.FaultCode = EndpointPushHandlerAlreadyRegistered.ToString(); throw me; } _endpointPushHandlers.Add(endpointId, handler); }
public override object Invoke(IMessage message) { object result = null; RemotingMessage remotingMessage = message as RemotingMessage; string operation = remotingMessage.operation; string className = this.DestinationDefinition.Properties.Source; //This property is provided for backwards compatibility. The best practice, however, is to not expose the underlying source of a //RemoteObject destination on the client and only one source to a destination. if (remotingMessage.source != null && remotingMessage.source != string.Empty) { if (className == "*") className = remotingMessage.source; if (className != remotingMessage.source) { string msg = __Res.GetString(__Res.Type_MismatchMissingSource, remotingMessage.source, this.DestinationDefinition.Properties.Source as string); throw new MessageException(msg, new TypeLoadException(msg)); } } if( className == null ) throw new TypeInitializationException("null", null); //Service mapping obsolete for Flex Remoting /* if (FluorineConfiguration.Instance.ServiceMap != null) { string method = remotingMessage.operation; if (FluorineConfiguration.Instance.ServiceMap.Contains(className)) { string serviceLocation = FluorineConfiguration.Instance.ServiceMap.GetServiceLocation(className); method = FluorineConfiguration.Instance.ServiceMap.GetMethod(className, method); if (log != null && log.IsDebugEnabled) log.Debug(__Res.GetString(__Res.Service_Mapping, className + "." + remotingMessage.operation, serviceLocation + "." + method)); className = serviceLocation; remotingMessage.operation = method; } } */ //Cache check string source = className + "." + operation; IList parameterList = remotingMessage.body as IList; string key = dotFlex.Configuration.CacheMap.GenerateCacheKey(source, parameterList); if (FluorineConfiguration.Instance.CacheMap.ContainsValue(key)) { result = dotFlex.Configuration.FluorineConfiguration.Instance.CacheMap.Get(key); if (result != null) { if (log != null && log.IsDebugEnabled) log.Debug(__Res.GetString(__Res.Cache_HitKey, operation, key)); return result; } } FactoryInstance factoryInstance = this.Destination.GetFactoryInstance(); factoryInstance.Source = className; object instance = factoryInstance.Lookup(); if( instance != null ) { try { Type type = instance.GetType(); bool isAccessible = TypeHelper.GetTypeIsAccessible(type); if (!isAccessible) { string msg = __Res.GetString(__Res.Type_InitError, type.FullName); throw new MessageException(msg, new TypeLoadException(msg)); } MethodInfo mi = MethodHandler.GetMethod(type, operation, parameterList); if (mi != null) { try { //Messagebroker checked xml configured security, check attributes too 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 = this.Destination.Service.GetMessageBroker().LoginManager.DoAuthorization(roles); if (!authorized) throw new UnauthorizedAccessException(__Res.GetString(__Res.Security_AccessNotAllowed)); } ParameterInfo[] parameterInfos = mi.GetParameters(); object[] args = new object[parameterInfos.Length]; parameterList.CopyTo(args, 0); TypeHelper.NarrowValues(args, parameterInfos); InvocationHandler invocationHandler = new InvocationHandler(mi); result = invocationHandler.Invoke(instance, args); } catch (TargetInvocationException exception) { MessageException messageException = null; if (exception.InnerException is MessageException) messageException = exception.InnerException as MessageException;//User code throws MessageException else messageException = new MessageException(exception.InnerException); if (log.IsDebugEnabled) log.Debug(__Res.GetString(__Res.Invocation_Failed, mi.Name, messageException.Message)); return messageException.GetErrorMessage(); //Do not throw here, we do not want to log user code exceptions. //throw messageException; } } else throw new MessageException(new MissingMethodException(className, operation)); } catch (MessageException) { throw; } catch (Exception exception) { MessageException messageException = new MessageException(exception); throw messageException; } finally { factoryInstance.OnOperationComplete(instance); } } else throw new MessageException( new TypeInitializationException(className, null) ); 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; } return result; }
public void WriteMessage(AMFMessage amfMessage) { try { base.WriteShort(amfMessage.Version); int headerCount = amfMessage.HeaderCount; base.WriteShort(headerCount); for(int i = 0; i < headerCount; i++) { this.WriteHeader(amfMessage.GetHeaderAt(i), ObjectEncoding.AMF0); } int bodyCount = amfMessage.BodyCount; base.WriteShort(bodyCount); for(int i = 0; i < bodyCount; i++) { ResponseBody responseBody = amfMessage.GetBodyAt(i) as ResponseBody; if (responseBody != null && !responseBody.IgnoreResults) { //Try to catch serialization errors if (this.BaseStream.CanSeek) { long position = this.BaseStream.Position; try { responseBody.WriteBody(amfMessage.ObjectEncoding, this); } catch (Exception exception) { this.BaseStream.Seek(position, SeekOrigin.Begin); //this.BaseStream.Position = position; #if !SILVERLIGHT if (log.IsFatalEnabled) log.Fatal(__Res.GetString(__Res.Amf_SerializationFail), exception); #endif ErrorResponseBody errorResponseBody; if (responseBody.RequestBody.IsEmptyTarget) { object content = responseBody.RequestBody.Content; if (content is IList) content = (content as IList)[0]; IMessage message = content as IMessage; MessageException messageException = new MessageException(exception); messageException.FaultCode = __Res.GetString(__Res.Amf_SerializationFail); errorResponseBody = new ErrorResponseBody(responseBody.RequestBody, message, messageException); } else errorResponseBody = new ErrorResponseBody(responseBody.RequestBody, exception); try { errorResponseBody.WriteBody(amfMessage.ObjectEncoding, this); } #if !SILVERLIGHT catch (Exception exception2) { if (log.IsFatalEnabled) log.Fatal(__Res.GetString(__Res.Amf_ResponseFail), exception2); throw; } #else catch (Exception) { throw; } #endif } } else responseBody.WriteBody(amfMessage.ObjectEncoding, this); } else { AMFBody amfBody = amfMessage.GetBodyAt(i); dotFlex.Util.ValidationUtils.ObjectNotNull(amfBody, "amfBody"); amfBody.WriteBody(amfMessage.ObjectEncoding, this); } } } #if !SILVERLIGHT catch(Exception exception) { if( log.IsFatalEnabled ) log.Fatal(__Res.GetString(__Res.Amf_SerializationFail), exception); throw; } #else catch (Exception) { throw; } #endif }