// 开启客户端
private void StartClient()
{
BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
IDictionary props = new Hashtable();
props["port"] = 0;
TcpChannel channel = new TcpChannel(props, clientProvider, serverProvider);
ChannelServices.RegisterChannel(channel);
//// 配置通道及传输格式
//string cfg = "Client.config";
//RemotingConfiguration.Configure(cfg);
// 由config中读取相关数据
string broadCastObjURL = ConfigurationManager.AppSettings["BroadCastObjURL"];
// 获取广播远程对象
watch = (IBroadCast)Activator.GetObject(typeof(IBroadCast), broadCastObjURL);
wrapper = new EventWrapper();
wrapper.LocalBroadCastEvent += new BroadCastEventHandler(BroadCastingMessage);
watch.BroadCastEvent += new BroadCastEventHandler(wrapper.BroadCasting);
SetSubscribe(true);
}
public async Task ReplaceAsync(T aggregate)
{
using (var session = dbContext.Database.Client.StartSession())
{
try
{
await session.WithTransaction(
async (s, ct) =>
{
aggregate.CheckState();
var filter = Builders <T> .Filter.Eq(MongoDefaultSettings.IdName, aggregate.Id.Value);
await collection.ReplaceOneAsync(filter, aggregate, new ReplaceOptions {
IsUpsert = false
});
foreach (var @event in aggregate.GetEvents())
{
var mongoEvent = new EventWrapper(Guid.NewGuid().ToString(), @event.GetType(), @event, aggregate.Id.Value);
var eventsCollection = session.Client.GetDatabase(mongoDbSettings.DatabaseName).GetCollection <EventWrapper>(MongoDefaultSettings.EventsDocumentName);
await eventsCollection.InsertOneAsync(mongoEvent);
}
});
}
catch (Exception exception)
{
logger.LogError($"{Messages.NonTransientExceptionCaught} ${exception.Message}.", exception);
}
}
}
public static void RegisterBlockPersistEvent(NeoSystem neoSystem)
{
if (_actor == null)
{
_actor = neoSystem.ActorSystem.ActorOf(EventWrapper <Blockchain.PersistCompleted> .Props(Blockchain_PersistCompleted));
}
}
private Func <object, BasicDeliverEventArgs, Task> Consumer_Received(string queue)
{
return(async(object sender, BasicDeliverEventArgs eventArgs) =>
{
var message = Encoding.UTF8.GetString(eventArgs.Body.Span);
var wrapper = new EventWrapper
{
Key = $"{eventArgs.Exchange}:{queue}:{eventArgs.RoutingKey}",
Exchange = eventArgs.Exchange,
Queue = queue,
RouteKey = eventArgs.RoutingKey,
Event = message,
};
try
{
await _handler.OnEvent(wrapper, eventArgs);
}
catch (Exception ex)
{
_logger.LogError($"ERROR Processing message \"{message}\", exception: {ex.Message}");
if (_channelDict.TryGetValue($"{eventArgs.Exchange}:{queue}", out var channel))
{
channel.BasicNack(eventArgs.DeliveryTag, false, false);
}
}
});
}
public EventNode(EventWrapper evt, SetMemberNode node, bool isSubscription)
{
_Event = evt;
_IsSubscription = isSubscription;
_Node = node;
_Callback = Expr.CastTransparent(node.Value, _Event.EventHandlerType);
}
void DoConsume()
{
tokenSource = new CancellationTokenSource();
task = Task.Factory.StartNew(async token =>
{
var cancellationToken = (CancellationToken)token;
while (!cancellationToken.IsCancellationRequested)
{
EventWrapper result = default;
try
{
var value = (string)await redis.GetDatabase().ListLeftPopAsync(settings.ListKey);
if (value == null)
{
await Task.Delay(TimeSpan.FromSeconds(1));
continue;
}
result = JsonSerializer.Deserialize <EventWrapper>(value);
}
catch (Exception e)
{
logger.LogError($"Error occured: {e.Message}");
continue;
}
logger.LogInformation($"Consume message '{result.Name}:{result.Message}'.");
var eventName = result.Name;
var eventMessage = result.Message;
await ProcessEventAsync(eventName, eventMessage);
}
}, tokenSource.Token);
}
public async Task SendStatus(StatusBase status, bool useQueue = true)
{
var t = status.GetType();
status.Name = t.Name;
status.DateTime = DateTime.UtcNow;
var ser = JsonConvert.SerializeObject(status);
var evt = new EventWrapper
{
Data = ser,
EventName = t.Name
};
var evtSer = JsonConvert.SerializeObject(evt);
if (!useQueue)
{
_storeStatus(evtSer);
}
else
{
await _mqttService.Send("events", evtSer);
}
}
private void Form1_Load(object sender, EventArgs e)
{
BinaryServerFormatterSinkProvider serverProvider = new
BinaryServerFormatterSinkProvider();
BinaryClientFormatterSinkProvider clientProvider = new
BinaryClientFormatterSinkProvider();
serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
IDictionary props = new Hashtable();
props["port"] = 0;
HttpChannel channel = new HttpChannel(props, clientProvider, serverProvider);
ChannelServices.RegisterChannel(channel, false);
watch = (IBroadCast)Activator.GetObject(
typeof(IBroadCast), "http://localhost:8080/BroadCastMessage.soap");
wrapper = new EventWrapper();
wrapper.LocalBroadCastEvent += new BroadCastEventHandler(BroadCastingMessage);
watch.BroadCastEvent += new BroadCastEventHandler(wrapper.BroadCasting);
//watch.BroadCastEvent += new BroadCastEventHandler(BroadCastingMessage);
}
public void StartClient()
{
BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider();
BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider();
serverProvider.TypeFilterLevel = TypeFilterLevel.Full;
IDictionary props = new Hashtable();
props["port"] = 0;
TcpChannel channel = new TcpChannel(props, clientProvider, serverProvider);
ChannelServices.RegisterChannel(channel);
// 由config中读取相关数据
string broadCastObjURL = ConfigurationManager.AppSettings["BroadCastObjURL"];
string upCastObjURL = ConfigurationManager.AppSettings["RobotUpCastObjURL"];
// 获取广播远程对象
watch = (IBroadCast)Activator.GetObject(typeof(IBroadCast), broadCastObjURL);
wrapper = new EventWrapper();
wrapper.LocalBroadCastEvent += new BroadCastEventHandler(broadCastHandler.OnBroadCastingInfo);
watch.BroadCastEvent += new BroadCastEventHandler(wrapper.BroadCasting);
// upcast
upCast = (IUpCast)Activator.GetObject(typeof(IUpCast), upCastObjURL);
}
private async Task HandleChangesAsync(IReadOnlyCollection <Change> changes, CancellationToken cancellationToken)
{
var migratedEventStore = GetMigratedEventStore();
var successEventStore = GetValidationSuccessEventStore();
var failureEventStore = GetValidationFailureEventStore();
foreach (var change in changes)
{
var @event = change.GetEvent(_eventTypeResolver);
var validator = _validators
.SingleOrDefault(m => m.IsSubscribedTo(@event));
EventWrapper expectedEventWrapper = validator != null
? validator.GetExpectedValue(@event, change)
: change;
EventWrapper actualEventWrapper;
try
{
actualEventWrapper = await migratedEventStore.LoadEventWrapperAsync(expectedEventWrapper.Id);
}
catch (Exception ex)
{
throw new ApplicationException(
$"Error when trying to load eventWrapper with Id" +
$" {expectedEventWrapper.Id}. {ex.Message} + {ex.InnerException?.Message}");
}
var completedEvent = new ValidationCompletedEvent()
{
OriginalId = expectedEventWrapper.Id,
ComparableId = actualEventWrapper.Id,
OriginalEventData = expectedEventWrapper.EventData.ToString(Formatting.None),
ComparableEventData = actualEventWrapper.EventData.ToString(Formatting.None),
OriginalEventType = expectedEventWrapper.EventType,
ComparableEventType = actualEventWrapper.EventType,
};
bool saved;
if (!Validator.Equals(expectedEventWrapper, actualEventWrapper))
{
saved = await failureEventStore.AppendToStreamAsync(change.StreamInfo.Id,
change.StreamInfo.Version - 1,
new[] { completedEvent });
}
else
{
saved = await successEventStore.AppendToStreamAsync(change.StreamInfo.Id,
change.StreamInfo.Version - 1,
new[] { completedEvent });
}
if (!saved)
{
throw new ApplicationException("Failed to save.");
}
}
}
public PTPEditorVM(PTP ptp)
{
int sourceInd = Static.EncodingManager.GetPersonaEncodingIndex(Settings.AppSetting.Default.PTPOldDefault);
if (sourceInd >= 0)
{
OldEncoding = sourceInd;
}
else
{
OldEncoding = 0;
}
sourceInd = Static.EncodingManager.GetPersonaEncodingIndex(Settings.AppSetting.Default.PTPNewDefault);
if (sourceInd >= 0)
{
NewEncoding = sourceInd;
}
else
{
NewEncoding = 0;
}
sourceInd = Static.BackManager.GetBackgroundIndex(Settings.AppSetting.Default.PTPBackgroundDefault);
if (sourceInd >= 0)
{
SelectedBackgroundIndex = sourceInd;
}
else
{
SelectedBackgroundIndex = 0;
}
View = Settings.AppSetting.Default.PTPImageView;
EncodingManagerEW = new EventWrapper(Static.EncodingManager, this);
foreach (var a in ptp.names)
{
Names.Add(new PTPNameEditVM(a, OldEncoding, NewEncoding, SelectedBackgroundIndex));
}
foreach (var a in ptp.msg)
{
var name = Names.FirstOrDefault(x => x.Index == a.CharacterIndex);
Tuple <ImageDrawing, ImageDrawing, ImageDrawing, RectangleGeometry> tuple;
if (name == null)
{
tuple = new Tuple <ImageDrawing, ImageDrawing, ImageDrawing, RectangleGeometry>(null, null, BackgroundDrawing, ClipGeometry);
}
else
{
tuple = new Tuple <ImageDrawing, ImageDrawing, ImageDrawing, RectangleGeometry>(name.OldNameVisual.TextDrawing, name.NewNameVisual.TextDrawing, BackgroundDrawing, ClipGeometry);
}
MSG.Add(new PTPMsgVM(a, tuple, Settings.AppSetting.Default.PTPOldDefault, Settings.AppSetting.Default.PTPNewDefault, SelectedBackgroundIndex));
}
}
protected virtual void Start()
{
RotateEvent = new EventWrapper <IRotateHandler, MultiTouchPointerEventData>((h, e) => h.OnRotate(this, e, DeltaRotate));
PanEvent = new EventWrapper <IPanHandler, MultiTouchPointerEventData>((h, e) => h.OnPan(this, e, e.centroidDelta));
PinchEvent = new EventWrapper <IPinchHandler, MultiTouchPointerEventData>((h, e) => h.OnPinch(this, e, DeltaPinch));
GestureStartEvent = new EventWrapper <IGestureStartHandler, MultiTouchPointerEventData>((h, e) => h.OnGestureStart(e));
GestureEndEvent = new EventWrapper <IGestureEndHandler, MultiTouchPointerEventData>((h, e) => h.OnGestureEnded(e));
}
public EventServer(int clientCount)
{
wrappers = new EventWrapper[Math.Max(clientCount, defaultClientCount)];
for (int i = 0; i < wrappers.Length; i++)
{
wrappers[i] = new EventWrapper();
}
}
public void EventWrapper_Should_Be_Equal_To_Himself()
{
// Arrange, Act
var wrappedEvt = new EventWrapper <int>(new InputAggregateCreated(1));
// Assert
wrappedEvt.Equals(wrappedEvt).Should().BeTrue();
}
private void HandleEvent(object service, EventWrapper @event)
{
var methodInfo = service.GetType().GetMethod("Handle");
var eventParameter = new object[1] {
@event.EventValue
};
methodInfo.Invoke(service, eventParameter);
}
public EventServer(int clientCount)
{
//wrappers = new EventWrapper[Math.Max(clientCount / distributionFactor, distributionFactor)];
wrappers = new EventWrapper[Math.Max(clientCount, defaultClientCount)];
for (int i = 0; i < wrappers.Length; i++)
{
wrappers[i] = new EventWrapper();
}
}
public EventWrapper GetExpectedValue(IEvent e, EventWrapper eventWrapper)
{
if (_transformers.TryGetValue(eventWrapper.EventType, out Func <IEvent, EventWrapper, EventWrapper> handler))
{
return(handler(e, eventWrapper));
}
return(eventWrapper);
}
public async Task ModifyAsync(Action <T> modifyLogic, IId <string> id)
{
await Policy
.Handle <MongoWaitQueueFullException>()
.WaitAndRetryForeverAsync(retryAttempt => TimeSpan.FromMilliseconds(Math.Pow(2, retryAttempt)))
.ExecuteAsync(async() =>
{
using (var session = dbContext.Database.Client.StartSession())
{
try
{
await session.WithTransaction(
async(s, ct) =>
{
var entityCollection = session.Client.GetDatabase(mongoDbSettings.DatabaseName).GetCollection <T>(MongoUtils.GetCollectionName <T>());
var eventsCollection = session.Client.GetDatabase(mongoDbSettings.DatabaseName).GetCollection <EventWrapper>(MongoDefaultSettings.EventsDocumentName);
ReplaceOneResult result;
T foundAggregate;
do
{
var filter = Builders <T> .Filter.Eq(MongoDefaultSettings.IdName, id.Value);
foundAggregate = await GetFirstFromCollectionAsync(entityCollection, filter);
var version = foundAggregate.Etag;
foundAggregate.RegenerateEtag();
modifyLogic(foundAggregate);
foundAggregate.CheckState();
filter = filter & Builders <T> .Filter.Eq(MongoDefaultSettings.EtagName, version);
result = await entityCollection.ReplaceOneAsync(filter, foundAggregate, new ReplaceOptions {
IsUpsert = false
});
} while (result.ModifiedCount != 1);
//events are saved after sucessfull transformation
if (result.ModifiedCount == 1)
{
foreach (var @event in foundAggregate.GetEvents())
{
var mongoEvent = new EventWrapper(Guid.NewGuid().ToString(), @event.GetType(), @event, foundAggregate.Id.Value);
eventsCollection.InsertOne(mongoEvent);
}
}
});
}
catch (MongoWaitQueueFullException exception)
{
logger.LogError($"{Messages.NonTransientExceptionCaught} ${exception.Message}.", exception);
throw;
}
}
});
}
public NoopEventReaction(
ILogger <NoopEventReaction <TCallbackEvent> > logger,
EventWrapper eventWrapper)
{
_logger = logger;
_eventWrapper = eventWrapper;
Event = _eventWrapper.Event as TCallbackEvent
?? new TCallbackEvent();
}
public List <EventWrapper> RemoveEvent(int eventId, ApiDateTime date, EventRemoveType type)
{
var events = new List <EventWrapper>();
var evt = _dataProvider.GetEventById(eventId);
var cal = _dataProvider.GetCalendarById(Convert.ToInt32(evt.CalendarId));
if (evt.OwnerId.Equals(SecurityContext.CurrentAccount.ID) || CheckPermissions(evt, CalendarAccessRights.FullAccessAction, true) || CheckPermissions(cal, CalendarAccessRights.FullAccessAction, true))
{
if (type == EventRemoveType.AllSeries || evt.RecurrenceRule.Freq == Frequency.Never)
{
_dataProvider.RemoveEvent(eventId);
return(events);
}
else if (type == EventRemoveType.Single)
{
evt.RecurrenceRule.ExDates.Add(new RecurrenceRule.ExDate()
{
Date = date.UtcTime.Date, isDateTime = false
});
}
else if (type == EventRemoveType.AllFollowing)
{
evt.RecurrenceRule.Until = date.UtcTime.Date;
if (!evt.AllDayLong)
{
evt.RecurrenceRule.Until = evt.RecurrenceRule.Until.Add(evt.UtcStartDate.TimeOfDay);
}
}
evt = _dataProvider.UpdateEvent(int.Parse(evt.Id), int.Parse(evt.CalendarId), evt.OwnerId, evt.Name, evt.Description,
evt.UtcStartDate, evt.UtcEndDate, evt.RecurrenceRule, evt.AlertType, evt.AllDayLong,
evt.SharingOptions.PublicItems);
//define timeZone
TimeZoneInfo timeZone;
if (!CheckPermissions(cal, CalendarAccessRights.FullAccessAction, true))
{
timeZone = _dataProvider.GetTimeZoneForSharedEventsCalendar(SecurityContext.CurrentAccount.ID);
evt.CalendarId = SharedEventsCalendar.CalendarId;
}
else
{
timeZone = _dataProvider.GetTimeZoneForCalendar(SecurityContext.CurrentAccount.ID, int.Parse(evt.CalendarId));
}
events = new EventWrapper(evt, SecurityContext.CurrentAccount.ID, timeZone).GetList(evt.UtcStartDate, date.UtcTime.AddMonths(_monthCount));
}
else
{
_dataProvider.UnsubscribeFromEvent(eventId, SecurityContext.CurrentAccount.ID);
}
return(events);
}
public void EventWrapper_Should_Have_Key_Compose_With_StreamId_VersionId_InsertDate()
{
// Arrange
var wrappedEvt = new EventWrapper <int>(new InputAggregateCreated(1));
// Act
var keyeqquals = wrappedEvt.Key == $"1:0:{wrappedEvt.InsertDate}";
// Assert
keyeqquals.Should().BeTrue();
}
public void Broadcast(IPubSubEvent @event)
{
var eventWrapper = new EventWrapper
{
Type = @event.GetType(),
Json = JsonConvert.SerializeObject(@event)
};
_context.Clients.All.PubSubBusEvent(eventWrapper);
}
/// <summary>
/// Default Constructor
/// </summary>
public EventController()
{
CoreBuilder coreBuilder = CoreBuilder.GetInstance();
this.IEventMgr = coreBuilder.GetManager <IEventMgr>(CoreBuilder.IEVENTMGR);
this.EventWrapper = EventWrapper.GetInstance();
SystemLogWrapper = SystemLogWrapper.GetInstance();
}
public void PrepareData(EventsContext context, IEnumerable <DomainEvent> events)
{
if (events != null && events.Count() > 0)
{
var eventsWrapped = events.Select(ev => EventWrapper.Wrap(ev)).ToArray();
context.AddRange(eventsWrapped);
context.SaveChanges();
}
}
private void LoadEventSobjs()
{
var sobjs = Resources.LoadAll <EventSobj>("Event");
EventDict = new NameidSobjDict <EventSobj>(sobjs);
foreach (var sobj in sobjs)
{
var wrapper = new EventWrapper(sobj);
}
}
private EventWrapper <T> TryWrap <T>(T @event) where T : IntegratedEvent
{
//var context = _tenantContextAccessor.TenantContext;
var package = new EventWrapper <T>(@event)
{
TenantId = context?.TenantId
};
return(package);
}
public void EventWrapper_ToString_Should_Return_Concatatnation_Of_Key_And_EventId()
{
// Arrange
var wrappedEvt = new EventWrapper <int>(new InputAggregateCreated(1));
// Act
var keyeqquals = wrappedEvt.ToString() == $"1:0:{wrappedEvt.InsertDate}:{wrappedEvt.DomainEvent.EventId}";
// Assert
keyeqquals.Should().BeTrue();
}
public void EventWrapper_Should_Be_Equal_To_The_Version_Of_Himself_Seen_As_Object()
{
// Arrange, Act
var wrappedEvt1 = new EventWrapper <int>(new InputAggregateCreated(1));
var wrappedEvt2 = wrappedEvt1 as object;
// Assert
(wrappedEvt1 == wrappedEvt2).Should().BeTrue();
wrappedEvt1.Equals(wrappedEvt2).Should().BeTrue();
}
public void EventWrapper_Should_Be_Equal_betwween_Two_Instances_representing_The_Same_Thing()
{
// Arrange, Act
var wrappedEvt1 = new EventWrapper <int>(new InputAggregateCreated(1));
var wrappedEvt2 = new EventWrapper <int>(new InputAggregateCreated(1));
// Assert
(wrappedEvt1 == wrappedEvt2).Should().BeFalse();
wrappedEvt1.Equals(wrappedEvt2).Should().BeFalse();
}
public EventReaction(
ILogger <EventReaction <TEvent> > logger,
ISlackApiClient apiClient,
EventWrapper eventWrapper)
{
Logger = logger;
_apiClient = apiClient;
EventWrapper = eventWrapper;
Event = eventWrapper.Event as TEvent;
}
public void Connect()
{
_ro = (IServer)
Activator.GetObject(typeof(IServer),
"tcp://127.0.0.1:9999/FirstRemote");
EventWrapper ew = new EventWrapper();
ew.ParachuteEvent += Temping;
_ro.AddEvent(ew);
}
public static BaseEvent CreateWrapper(BaseEvent original, Action<BaseEvent, bool> passthrough, bool ignoreDelay, KSPEvent kspEvent)
{
// Create a new configuration node and fill this node with the original base event with the values
ConfigNode cn = new ConfigNode();
original.OnSave(cn);
// create the wrapper (used solely for its Invoke() method)
// this class keeps the:
// * pass through event (leading to the ModuleSPU.InvokeEvent() method)
// * the original event (button click event)
// * the ignore delay boolean value (true if the event ignore delay, false otherwise)
EventWrapper wrapper = new EventWrapper(original, passthrough, ignoreDelay);
// Create a new event, its main features are:
// 1. It retains its original base event invokable method: invokable directly through its InvokeOriginalEvent() method [useful for other mods, e.g. kOS]
// 2. Its new invoke() method which is in this wrapper class and decorated with and new KSPEvent category, namely "skip_control" (meaning we have already seen this event).
BaseEvent newEvent = new WrappedEvent(original, original.listParent, original.name, wrapper.Invoke, kspEvent);
// load the original base event values into the new base event
newEvent.OnLoad(cn);
return newEvent;
}
public void AddEvent(EventWrapper ew)
{
ParachuteEvent = new ParachuteDelegate(ew.ParachuteEventHandler);
}
/// <summary>
/// Detaches the currently associated instance
/// </summary>
public void Detach()
{
if (AssociatedObject != null)
{
EventWrapper eventHooker = new EventWrapper(this);
eventHooker.AssociatedObject = AssociatedObject;
EventInfo eventInfo = GetEventInfo(AssociatedObject.GetType(), EventName);
Delegate handler = eventHooker.GetEventHandler(eventInfo);
WindowsRuntimeMarshal.RemoveEventHandler<Delegate>(
etr => eventInfo.RemoveMethod.Invoke(AssociatedObject, new object[] { etr }), handler);
}
}
/// <summary>
/// Attaches an instance of a DependencyObject to this instance
/// </summary>
/// <param name="dependencyObject">The instance to attach</param>
public void Attach(DependencyObject dependencyObject)
{
AssociatedObject = dependencyObject;
if (!string.IsNullOrEmpty(EventName))
{
EventWrapper eventHooker = new EventWrapper(this);
eventHooker.AssociatedObject = dependencyObject;
EventInfo eventInfo = GetEventInfo(dependencyObject.GetType(), EventName);
if (eventInfo != null)
{
Delegate handler = eventHooker.GetEventHandler(eventInfo);
WindowsRuntimeMarshal.AddEventHandler<Delegate>(
dlg => (EventRegistrationToken)eventInfo.AddMethod.Invoke(dependencyObject, new object[] { dlg }),
etr => eventInfo.RemoveMethod.Invoke(dependencyObject, new object[] { etr }), handler);
}
}
}
public static IObservable<MouseEventArgs> GetMouseDowns(this Button button)
{
var wrapper = new EventWrapper<MouseEventArgs>();
button.MouseDown += wrapper.Handler;
return wrapper;
}
