protected void lnkBtnSave_Click(object sender, EventArgs e) { string busPlate = BusPlate.Text; string busName = BusName.Text; string seat = Seat.Text; string busTypeId = ddlBusType.SelectedValue.ToString(); string categoryID = ddlCategory.SelectedValue.ToString(); if (BLLBus.checkBusPlateExist(busPlate) != 0) { ClientScript.RegisterStartupScript(this.GetType(), "Notify", "alert('!!!Bus Plate existed. Please try again');", true); } else { Bus bus = new Bus(); bus.BusPlate = busPlate; bus.BusName = busName; bus.Seat = Int32.Parse(seat); bus.BusTypeID = Int32.Parse(busTypeId); bus.CategoryID = Int32.Parse(categoryID); bus.Status = true; BLLBus.InsertBus(bus); Response.Redirect("BusList.aspx"); } }
internal static Bus Build(BusBuilderConfiguration configuration) { var logger = configuration.Logger; logger.Debug("Constructing bus..."); var container = new PoorMansIoC(); RegisterPropertiesFromConfigurationObject(container, configuration); RegisterPropertiesFromConfigurationObject(container, configuration.LargeMessageStorageConfiguration); RegisterPropertiesFromConfigurationObject(container, configuration.Debugging); container.Register<Func<NamespaceManager>> (() => { var ns = NamespaceManager.CreateFromConnectionString(container.Resolve<ConnectionStringSetting>()); ns.Settings.OperationTimeout = configuration.DefaultTimeout; return ns; }); container.Register<Func<MessagingFactory>>(() => { var messagingFactory = MessagingFactory.CreateFromConnectionString(container.Resolve<ConnectionStringSetting>()); messagingFactory.PrefetchCount = container.Resolve<ConcurrentHandlerLimitSetting>(); return messagingFactory; }); if (configuration.Debugging.RemoveAllExistingNamespaceElements) { var namespaceCleanser = container.Resolve<NamespaceCleanser>(); namespaceCleanser.RemoveAllExistingNamespaceElements().Wait(); } logger.Debug("Creating message receivers..."); var messageReceiverManager = new MessageRecevierManager( container.Resolve<CommandMessageReceiverFactory>().CreateAll(), container.Resolve<MulticastEventMessageReceiverFactory>().CreateAll(), container.Resolve<CompetingEventMessageReceiverFactory>().CreateAll()); logger.Debug("Message receivers are all created."); var bus = new Bus(container.Resolve<IZombusLogger>(), container.Resolve<ICommandSender>(), container.Resolve<IEventSender>(), messageReceiverManager, container.Resolve<DeadLetterQueues>(), container.Resolve<IHeartbeat>()); bus.Starting += delegate { container.Resolve<AzureQueueManager>().WarmUp(); container.Resolve<PropertyInjector>().Bus = bus; }; bus.Disposing += delegate { container.Dispose(); }; logger.Info("Bus built. Job done!"); return bus; }
public void StartMessageShouldCreateANewMessageBusReadStream() { // Arrange var bus = new Bus(_mockConfiguration.Object); var mockStream = new Mock<IMessageBusReadStream>(); mockStream.Setup(x => x.HandlerCount).Returns(1); _mockConsumerPool.Setup(x => x.AddConsumer(It.IsAny<string>(), It.IsAny<IList<string>>(), It.Is<ConsumerEventHandler>(y => AssignEventHandler(y)), It.IsAny<IConfiguration>())); var mockProcessor = new Mock<IStreamProcessor>(); _mockContainer.Setup(x => x.GetInstance<IStreamProcessor>(It.Is<Dictionary<string, object>>(y => y["container"] == _mockContainer.Object))).Returns(mockProcessor.Object); mockProcessor.Setup(x => x.ProcessMessage(It.IsAny<FakeMessage1>(), mockStream.Object)); _mockConfiguration.Setup(x => x.GetMessageBusReadStream()).Returns(mockStream.Object); var message = new FakeMessage1(Guid.NewGuid()) { Username = "******" }; bus.StartConsuming(); // Act _fakeEventHandler(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(message)), typeof(FakeMessage1).AssemblyQualifiedName, new Dictionary<string, object> { { "Start", "" }, { "SequenceId", Encoding.UTF8.GetBytes("TestSequence") }, { "SourceAddress", Encoding.UTF8.GetBytes("Source") }, { "RequestMessageId", Encoding.UTF8.GetBytes("MessageId") }, { "MessageType", Encoding.UTF8.GetBytes("ByteStream")} }); // Assert mockProcessor.Verify(x => x.ProcessMessage(It.IsAny<FakeMessage1>(), It.IsAny<IMessageBusReadStream>()), Times.Once); }
public virtual async Task Given(ITestHarnessBusFactory busFactory) { Bus = (Bus) busFactory.Create(); Console.WriteLine(); Console.WriteLine(); }
public void StartConsumingShouldConsumeAllMessageTypes() { // Arrange var bus = new Bus(_mockConfiguration.Object); _mockConsumer.Setup(x => x.ConsumeMessageType(It.IsAny<string>())); var handlerReferences = new List<HandlerReference> { new HandlerReference { HandlerType = typeof (FakeHandler1), MessageType = typeof (FakeMessage1) }, new HandlerReference { HandlerType = typeof (FakeHandler2), MessageType = typeof (FakeMessage2) } }; _mockContainer.Setup(x => x.GetHandlerTypes()).Returns(handlerReferences); _mockConsumerPool.Setup(x => x.AddConsumer(It.IsAny<string>(), It.Is<IList<string>>(m => m.Contains(typeof(FakeMessage1).FullName.Replace(".", string.Empty)) && m.Contains(typeof(FakeMessage2).FullName.Replace(".", string.Empty))), It.IsAny<ConsumerEventHandler>(), It.IsAny<IConfiguration>())); // Act bus.StartConsuming(); // Assert _mockContainer.VerifyAll(); _mockConsumerPool.Verify(x => x.AddConsumer(It.IsAny<string>(), It.Is<IList<string>>(m => m.Contains(typeof(FakeMessage1).FullName.Replace(".", string.Empty)) && m.Contains(typeof(FakeMessage2).FullName.Replace(".", string.Empty))), It.IsAny<ConsumerEventHandler>(), It.IsAny<IConfiguration>()), Times.Once); }
public static void Init() { var bus = new Bus(); var cashier = new Cashier(bus); var barista = new Barista(Guid.NewGuid(), bus); var repository = new SagaRepository<OrderFufillment>(bus); bus.RouteToSaga(repository, (DrinkOrdered e) => e.OrderId); bus.RouteToSaga(repository, (DrinkPrepared e) => e.OrderId); bus.RouteToSaga(repository, (PaymentReceived e) => e.OrderId); bus.Register<OrderDrink>(c => cashier.Order(c.OrderId, c.Drink)); bus.RegisterOnThreadPool<Pay>(c => cashier.Pay(c.OrderId, PaymentMethod.CreditCard, c.Amount)); bus.RegisterOnThreadPool<PrepareDrink>(c => barista.PrepareDrink(c.OrderId, c.Drink)); bus.Register<NotifyCustomer>(c => { Console.WriteLine("{0} is ready", c.OrderId); ThreadPool.QueueUserWorkItem(_ => bus.Send(new Pay { OrderId = c.OrderId, Amount = 12m })); }); ServiceLocator.RegisterDispatcher<Command>(bus.Send); WindowsCommunicationFoundation.RegisterServiceLayer<Sales>(); }
public static Point Interpolate(Bus bus, List<Point> path, double timeNow) { int lastTime = bus.lastStop.stopMinuteTime; int nextTime = bus.nextStop.stopMinuteTime; double fractionComplete = (timeNow - lastTime) / (nextTime - lastTime); double distanceRequired = bus.lengthOfLeg * fractionComplete; double finalLineFraction = 0; bool atThePoint = false; int i = bus.lastStopIndex; while (!atThePoint) { double lineLength = Distance(path[i], path[i + 1]); if (lineLength > distanceRequired) { atThePoint = true; finalLineFraction = distanceRequired / lineLength; } else { distanceRequired -= lineLength; i++; } } int x = (int)(path[i].X + finalLineFraction * (path[i + 1].X - path[i].X)); int y = (int)(path[i].Y + finalLineFraction * (path[i + 1].Y - path[i].Y)); return new Point((int)x, (int)y); }
public void CreateStreamShouldCreateAMessageBusWriteStream() { // Arrange var mockConfiguration = new Mock<IConfiguration>(); var mockProducer = new Mock<IProducer>(); var mockContainer = new Mock<IBusContainer>(); var mockRequestConfiguration = new Mock<IRequestConfiguration>(); var mockStream = new Mock<IMessageBusWriteStream>(); mockConfiguration.Setup(x => x.GetContainer()).Returns(mockContainer.Object); mockConfiguration.Setup(x => x.GetProducer()).Returns(mockProducer.Object); mockConfiguration.SetupGet(x => x.TransportSettings).Returns(new TransportSettings ()); mockConfiguration.Setup(x => x.GetRequestConfiguration(It.IsAny<Guid>())).Returns(mockRequestConfiguration.Object); mockConfiguration.Setup(x=> x.GetMessageBusWriteStream(It.IsAny<IProducer>(), "TestEndpoint", It.IsAny<string>(), It.IsAny<IConfiguration>())).Returns(mockStream.Object); var task = new Task(() => { }); mockRequestConfiguration.Setup(x => x.SetHandler(It.IsAny<Action<object>>())).Returns(task); var message = new FakeMessage1(Guid.NewGuid()) { Username = "******" }; mockProducer.Setup(x => x.Send(It.IsAny<string>(), It.IsAny<Type>(), It.IsAny<byte[]>(), It.IsAny<Dictionary<string, string>>())).Callback(task.Start); // Act var bus = new Bus(mockConfiguration.Object); // Act var stream = bus.CreateStream("TestEndpoint", message); // Assert Assert.NotNull(stream); Assert.Equal(mockStream.Object, stream); }
public static void Main() { BusG.Init (); Application.Init (); Window win = new Window ("D-Bus#"); win.SetDefaultSize (640, 480); win.Destroyed += delegate {Application.Quit ();}; win.ShowAll (); bus = Bus.Session; sysBus = Bus.System.GetObject<IBus> ("org.freedesktop.DBus", new ObjectPath ("/org/freedesktop/DBus")); string bus_name = "org.ndesk.gtest"; ObjectPath path = new ObjectPath ("/org/ndesk/test"); if (bus.RequestName (bus_name) == RequestNameReply.PrimaryOwner) { //create a new instance of the object to be exported demo = new DemoObject (); sysBus.NameOwnerChanged += demo.FireChange; bus.Register (path, demo); } else { //import a remote to a local proxy demo = bus.GetObject<DemoObject> (bus_name, path); } //run the main loop Application.Run (); }
public void CanPublish() { var mockRepository = new MockRepository(); var config = mockRepository.DynamicMock<IBrokerConfiguration>(); var connFactory = mockRepository.DynamicMock<IBrokerConnectionFactory>(); var conn = mockRepository.DynamicMock<IBrokerConnection>(); var consumer = mockRepository.DynamicMock<IRegisteredConsumer>(); var message = new TestMessage(); using (mockRepository.Record()) { SetupResult.For(consumer.MessageType).Return(typeof(TestMessage)); SetupResult.For(connFactory.CreateConnection()).Return(conn); SetupResult.For(config.Exchange).Return("ex"); SetupResult.For(config.ConnectionFactory).Return(connFactory); SetupResult.For(config.RegisteredConsumers).Return(new Dictionary<Type, IList<IRegisteredConsumer>> { { typeof(TestMessage), new List<IRegisteredConsumer> { consumer } } }); ; SetupResult.For(conn.IsOpen).Return(true); Expect.Call(() => conn.Publish<TestMessage>(null)) .IgnoreArguments() .WhenCalled(mi => { var envelope = mi.Arguments[0]; Assert.IsAssignableFrom(typeof(IMessageEnvelope<TestMessage>), envelope); Assert.Same(message, ((IMessageEnvelope<TestMessage>)envelope).Message); }); } using (mockRepository.Playback()) { var bus = new Bus(config); bus.Publish(message); } }
public void ClosesOpenConnectionOnDispose() { var mockRepository = new MockRepository(); var config = mockRepository.DynamicMock<IBrokerConfiguration>(); var connFactory = mockRepository.DynamicMock<IBrokerConnectionFactory>(); var conn = mockRepository.DynamicMock<IBrokerConnection>(); var consumer = mockRepository.DynamicMock<IRegisteredConsumer>(); using (mockRepository.Record()) { SetupResult.For(consumer.MessageType).Return(typeof (TestMessage)); SetupResult.For(connFactory.CreateConnection()).Return(conn); SetupResult.For(config.ConnectionFactory).Return(connFactory); SetupResult.For(config.RegisteredConsumers).Return(new Dictionary<Type, IList<IRegisteredConsumer>> { { typeof(TestMessage), new List<IRegisteredConsumer> { consumer } } }); SetupResult.For(conn.IsOpen).Return(true); Expect.Call(conn.Close); } using (mockRepository.Playback()) { var bus = new Bus(config); bus.GetLiveConnection(); bus.Dispose(); } }
void Awake() { bus = GetComponent<Bus>(); bus.PropertyChanged += OnPropertyChanged; audio = gameObject.AddComponent<AudioSource>(); }
public static void Main() { BusG.Init (); Application.Init (); Button btn = new Button ("Click me"); btn.Clicked += OnClick; VBox vb = new VBox (false, 2); vb.PackStart (btn, false, true, 0); Window win = new Window ("D-Bus#"); win.SetDefaultSize (640, 480); win.Add (vb); win.Destroyed += delegate {Application.Quit ();}; win.ShowAll (); bus = Bus.Session; string bus_name = "org.ndesk.gtest"; ObjectPath path = new ObjectPath ("/org/ndesk/test"); if (bus.RequestName (bus_name) == RequestNameReply.PrimaryOwner) { //create a new instance of the object to be exported demo = new DemoObject (); bus.Register (path, demo); } else { //import a remote to a local proxy demo = bus.GetObject<DemoObject> (bus_name, path); } //run the main loop Application.Run (); }
public Coordinator(Bus.Attachment.IFactory attachmentFactory, Bus.Object.IFactory objectFactory) { _attachmentFactory = attachmentFactory; _objectFactory = objectFactory; _objects = new Dictionary<string, Object.Instance>(); }
static void Main(string[] args) { IBusLog log = new BusLog(); try { using (IBus bus = new Bus(@".\private$\testreq", @".\private$\", @".\private$\testack", null, null, log)) { bus.BusLoggingLevel = BusLoggingLevel.Diagnostic; bus.RegisterHandler<ARequest, AResponse, AHandler>(); bus.RegisterHandler<BRequest, BResponse, BHandler>(); bus.RegisterHandler<CRequest, CResponse, CHandler>(); bus.RegisterHandler<DRequest, DResponse, DHandler>(); bus.StartListening(); log.Info("Server ready. Press Enter to quit."); Console.ReadLine(); bus.StopListening(); Console.WriteLine("Total sent: " + bus.TotalSent); Console.WriteLine("Total received: " + bus.TotalReceived); Thread.Sleep(5000); } } catch (Exception ex) { log.Error(ex); Thread.Sleep(5000); } }
public void Test() { var bus = new Bus<Int32>(); bus.SendLocal(34); /* bus.Where(i => i > 100).Subscribe(i => { Console.WriteLine("New Message Arrived {0}", i); }); var dis = bus.Subscribe(i => { Console.WriteLine("||| New Message Arrived {0}", i); });*/ bus.SendLocal(346); bus.Run(); bus.SendLocal(777); // dis.Dispose(); bus.SendLocal(888); }
public static IBus Connect(DepotSettings settings) { if (settings == null) { throw new ArgumentNullException("settings"); } settings.Validate(); var connectionString = settings.ConnectionString; var connectionFactory = settings.ConnectionFactoryBuilder(); var consumerFactory = settings.ConsumerFactoryBuilder(); var modelFactory = connectionFactory.Create(new Uri(connectionString)); var messageSerializers = settings.MessageSerializers; var bus = new Bus( modelFactory, consumerFactory, new RequesterFactory(), new PublisherFactory(messageSerializers), new SubscriptionFactory(modelFactory, messageSerializers)); foreach (var concern in settings.StartupConcerns) { concern.Run(bus); } return bus; }
private static void RegisterHandlersInAssembly(IEnumerable<Assembly> assemblies, Type messageType, Bus.Bus bus, Type[] ctorArgTypes, object[] ctorArgs) { //among classes in handlers assemblies select any which handle specified message type var handlerTypesWithMessages = assemblies .SelectMany(a => a.GetTypes()) .Where(t => !t.IsInterface && t.GetInterfaces() .Any(i => i.IsGenericType && i.GetGenericTypeDefinition() == typeof(IHandle<>) && messageType.IsAssignableFrom(i.GetGenericArguments().First()))) .Select(t => new { Type = t, MessageTypes = t.GetInterfaces().Select(i => i.GetGenericArguments().First()) }); foreach (var handler in handlerTypesWithMessages) { var ctor = handler.Type.GetConstructor(ctorArgTypes); var handlerInstance = ctor.Invoke(ctorArgs); foreach (Type msgType in handler.MessageTypes) { MethodInfo handleMethod = handler.Type .GetMethods() .Where(m => m.Name.Equals("Handle", StringComparison.OrdinalIgnoreCase)) .First(m => msgType.IsAssignableFrom(m.GetParameters().First().ParameterType)); Type actionType = typeof(Action<>).MakeGenericType(msgType); Delegate handlerDelegate = Delegate.CreateDelegate(actionType, handlerInstance, handleMethod); MethodInfo genericRegister = bus.GetType().GetMethod("RegisterHandler").MakeGenericMethod(new[] { msgType }); genericRegister.Invoke(bus, new[] { handlerDelegate }); } } }
public static void Main() { BusG.Init (); Application.Init (); btn = new Button ("Click me"); btn.Clicked += OnClick; VBox vb = new VBox (false, 2); vb.PackStart (btn, false, true, 0); Window win = new Window ("D-Bus#"); win.SetDefaultSize (640, 480); win.Add (vb); win.Destroyed += delegate {Application.Quit ();}; win.ShowAll (); bus = Bus.Session; string bus_name = "org.ndesk.gtest"; ObjectPath path = new ObjectPath ("/org/ndesk/btn"); if (bus.RequestName (bus_name) == RequestNameReply.PrimaryOwner) { bus.Register (path, btn); rbtn = btn; } else { rbtn = bus.GetObject<Button> (bus_name, path); } //run the main loop Application.Run (); }
public void BusCanRouteMessages() { // Arrange var sut = new Bus(); // Assert Assert.True(sut.TotalMessagesDelivered > 0); }
public void Painter_should_paint_bus_with_given_color() { var painter = new Painter(); var bus = new Bus("REG"); painter.Paint(bus, Color.HotPink); Assert.AreEqual(Color.HotPink, bus.Color); }
public void When_sending_a_command_and_there_are_no_command_handlers_should_throw_exception() { var serviceContainer = new ServiceContainer(); var bus = new Bus(serviceContainer.GetAllInstances); var command = new Command(); Assert.Throws<NotSupportedException>(() => bus.SendAsync(command).Wait()); }
protected virtual async Task Given(IConfigurationScenario<BusBuilderConfiguration> scenario) { Instance = scenario.CreateInstance(); Reconfigure(); Bus = Instance.Configuration.Build(); MethodCallCounter = MethodCallCounter.CreateInstance(Bus.InstanceId); await Bus.Start(); }
protected void Page_Load(object sender, EventArgs e) { busPlate = Request.QueryString["BusPlate"].ToString(); bus = BLLBus.getBusByID(busPlate)[0]; if (!IsPostBack) { FillData(); } }
public void OnBusEnter(Bus bus) { if(State == EState.WAITING) { State = EState.BOARDING; targetBus = bus; bus.Queue(this); } }
public ExpenseReportController(IExpenseReportBuilder expenseReportBuilder, IUserSession session, IWorkflowFacilitator workflowFacilitator, Bus bus, ICalendar calendar) { _expenseReportBuilder = expenseReportBuilder; _session = session; _workflowFacilitator = workflowFacilitator; _bus = bus; _calendar = calendar; }
void Awake() { vehicle = GetComponent<Vehicle>(); bus = GetComponent<Bus>(); vehicle.PropertyChanged += OnPropertyChanged; bus.PropertyChanged += OnPropertyChanged; doorsUI.onClick.AddListener(() => bus.ToggleDoors()); }
public void Status_Initialised() { var _busConfigurationBuilder = new BusConfigurationBuilder(); _busConfigurationBuilder.ConnectionUris.Add(TestingConfiguration.LocalConnectionUri); var _busConfirguration = _busConfigurationBuilder.Build(); var _SUT = new Bus(_busConfirguration); Assert.AreEqual(BusStatus.Initialised, _SUT.Status); }
public static void Main(string[] args) { Task.Run(() => { var bus = new Bus(); var srv = new BusServer("uuid:" + Guid.NewGuid(), "RNet Bus", "Russound", "CAM6.6", bus); srv.Start(); }).Wait(); Console.ReadLine(); }
public Task OnStart() { // Make sure the bus is started _bus = _container.Resolve<Bus>(); Task startBus = _bus.Start(); // Execute the scheduler that we can cancel on stop _schedulerExecution = _container.Resolve<SampleDataJobScheduler>().Run(_cancelTokenSource.Token); return startBus; }
public void Handle(MessageInitiatingSaga message) { Context.SagaId = Data.Id; Bus.SendLocal(new MessageSentBySaga()); }
public EditFailedMessages() { Get["/edit/config"] = _ => Negotiate.WithModel(GetEditConfiguration()); Post["/edit/{failedmessageid}", true] = async(parameters, token) => { if (!Settings.AllowMessageEditing) { logging.Info("Message edit-retry has not been enabled."); return(HttpStatusCode.NotFound); } string failedMessageId = parameters.FailedMessageId; if (string.IsNullOrEmpty(failedMessageId)) { return(HttpStatusCode.BadRequest); } var edit = this.Bind <EditMessageModel>(); FailedMessage failedMessage; using (var session = Store.OpenAsyncSession()) { failedMessage = await session.LoadAsync <FailedMessage>(FailedMessage.MakeDocumentId(failedMessageId)).ConfigureAwait(false); } if (failedMessage == null) { logging.WarnFormat("The original failed message could not be loaded for id={0}", failedMessageId); return(HttpStatusCode.BadRequest); } //WARN /* * failedMessage.ProcessingAttempts.Last() return the lat retry attempt. * In theory between teh time someone edits a failed message and retry it someone else * could have retried the same message without editing. If this is the case "Last()" is * not anymore the same message. * Instead of using Last() it's probably better to select the processing attempt by looking for * one with the same MessageID */ if (LockedHeaderModificationValidator.Check(GetEditConfiguration().LockedHeaders, edit.MessageHeaders.ToDictionary(x => x.Key, x => x.Value), failedMessage.ProcessingAttempts.Last().Headers)) { logging.WarnFormat("Locked headers have been modified on the edit-retry for MessageID {0}.", failedMessageId); return(HttpStatusCode.BadRequest); } if (string.IsNullOrWhiteSpace(edit.MessageBody) || edit.MessageHeaders == null) { logging.WarnFormat("There is no message body on the edit-retry for MessageID {0}.", failedMessageId); return(HttpStatusCode.BadRequest); } // Encode the body in base64 so that the new body doesn't have to be escaped var base64String = Convert.ToBase64String(Encoding.UTF8.GetBytes(edit.MessageBody)); await Bus.SendLocal(new EditAndSend { FailedMessageId = failedMessageId, NewBody = base64String, NewHeaders = edit.MessageHeaders.ToDictionary(kvp => kvp.Key, kvp => kvp.Value) }).ConfigureAwait(false); return(HttpStatusCode.Accepted); }; }
public DemoValue1Characteristic(Bus bus, int index, Service service) : base(bus, index, UUID, new[] { "read" }, service) { }
public FormDetailBus(Bus bus) { InitializeComponent(); DteByHour.Value = DateTime.Now; this.bus = bus; }
protected override async Task When() { _response = await Bus.Request(new SomeRequest(), _timeout); }
public void Handle(ReplicationMessage.DataChunkBulk message) { Interlocked.Decrement(ref FlushMessagesInQueue); try { if (_subscriptionId != message.SubscriptionId) { return; } if (_activeChunk != null) { ReplicationFail("Data chunk bulk received, but we have active chunk for receiving raw chunk bulks."); } var chunk = Writer.CurrentChunk; if (chunk.ChunkHeader.ChunkStartNumber != message.ChunkStartNumber || chunk.ChunkHeader.ChunkEndNumber != message.ChunkEndNumber) { Log.Error("Received DataChunkBulk for TFChunk {0}-{1}, but active chunk is {2}-{3}.", message.ChunkStartNumber, message.ChunkEndNumber, chunk.ChunkHeader.ChunkStartNumber, chunk.ChunkHeader.ChunkEndNumber); return; } if (_subscriptionPos != message.SubscriptionPosition) { Log.Error("Received DataChunkBulk at SubscriptionPosition {0} (0x{0:X}) while current SubscriptionPosition is {1} (0x{1:X}).", message.SubscriptionPosition, _subscriptionPos); return; } _framer.UnFrameData(new ArraySegment <byte>(message.DataBytes)); _subscriptionPos += message.DataBytes.Length; if (message.CompleteChunk) { Log.Trace("Completing data chunk {0}-{1}...", message.ChunkStartNumber, message.ChunkEndNumber); Writer.CompleteChunk(); if (_framer.HasData) { ReplicationFail("There is some data left in framer when completing chunk."); } _subscriptionPos = chunk.ChunkHeader.ChunkEndPosition; _framer.Reset(); } } catch (Exception exc) { Log.ErrorException(exc, "Exception in writer."); throw; } finally { Flush(); } if (message.CompleteChunk || _subscriptionPos - _ackedSubscriptionPos >= MasterReplicationService.ReplicaAckWindow) { _ackedSubscriptionPos = _subscriptionPos; Bus.Publish(new ReplicationMessage.AckLogPosition(_subscriptionId, _ackedSubscriptionPos)); } }
public void AddToBuses(Bus bus) { base.AddObject("Buses", bus); }
private void HoaDon_Load(object sender, EventArgs e) { dgvHoadon.DataSource = Bus.GetListHoadon(); cbxMathuthu.DataSource = Bus.GetListThuthu(); cbxMathuthu.ValueMember = "matt"; }
public void Hienthi(string hoadon) { dgvHoadon.DataSource = Bus.SearchHoadon(hoadon); }
public IBus StartSQLEndpoint(bool useOutbox) { return(Bus.Create(EndpointConfig.CreateSQLConfiguration(useOutbox)).Start()); }
public IBus StartAzureEndpoint(string azureSBConnection, bool useOutbox, bool disableTx) { return(Bus.Create(EndpointConfig.CreateAzureBusConfiguration(azureSBConnection, useOutbox, disableTx)).Start()); }
public async Task <IHttpActionResult> Put(AddSliderToDiscountCommand command) { var response = await Bus.Send <AddSliderToDiscountCommand, AddSliderToDiscountCommandResponse>(command); return(Ok(response)); }
public SingleVNode(TFChunkDb db, SingleVNodeSettings vNodeSettings, SingleVNodeAppSettings appSettings, bool dbVerifyHashes) { Ensure.NotNull(db, "db"); Ensure.NotNull(vNodeSettings, "vNodeSettings"); db.OpenVerifyAndClean(dbVerifyHashes); _tcpEndPoint = vNodeSettings.ExternalTcpEndPoint; _httpEndPoint = vNodeSettings.ExternalHttpEndPoint; _outputBus = new InMemoryBus("OutputBus"); _controller = new SingleVNodeController(Bus, _httpEndPoint); _mainQueue = new QueuedHandler(_controller, "MainQueue"); _controller.SetMainQueue(MainQueue); //MONITORING var monitoringInnerBus = new InMemoryBus("MonitoringInnerBus", watchSlowMsg: false); var monitoringRequestBus = new InMemoryBus("MonitoringRequestBus", watchSlowMsg: false); var monitoringQueue = new QueuedHandler(monitoringInnerBus, "MonitoringQueue", watchSlowMsg: true, slowMsgThresholdMs: 100); var monitoring = new MonitoringService(monitoringQueue, monitoringRequestBus, db.Config.WriterCheckpoint, db.Config.Path, appSettings.StatsPeriod); Bus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.SystemInit, Message>()); Bus.Subscribe(monitoringQueue.WidenFrom <SystemMessage.BecomeShuttingDown, Message>()); monitoringInnerBus.Subscribe <SystemMessage.SystemInit>(monitoring); monitoringInnerBus.Subscribe <SystemMessage.BecomeShuttingDown>(monitoring); monitoringInnerBus.Subscribe <MonitoringMessage.GetFreshStats>(monitoring); //STORAGE SUBSYSTEM var indexPath = Path.Combine(db.Config.Path, "index"); var tableIndex = new TableIndex(indexPath, () => new HashListMemTable(maxSize: 2000000), maxSizeForMemory: 1000000, maxTablesPerLevel: 2); var readIndex = new ReadIndex(_mainQueue, TFConsts.ReadIndexReaderCount, () => new TFChunkSequentialReader(db, db.Config.WriterCheckpoint, 0), () => new TFChunkReader(db, db.Config.WriterCheckpoint), tableIndex, new XXHashUnsafe(), new LRUCache <string, StreamCacheInfo>(TFConsts.MetadataCacheCapacity)); var writer = new TFChunkWriter(db); var storageWriter = new StorageWriter(_mainQueue, _outputBus, writer, readIndex); var storageReader = new StorageReader(_mainQueue, _outputBus, readIndex, TFConsts.StorageReaderHandlerCount, db.Config.WriterCheckpoint); monitoringRequestBus.Subscribe <MonitoringMessage.InternalStatsRequest>(storageReader); var chaser = new TFChunkChaser(db, db.Config.WriterCheckpoint, db.Config.ChaserCheckpoint); var storageChaser = new StorageChaser(_mainQueue, chaser, readIndex); _outputBus.Subscribe <SystemMessage.SystemInit>(storageChaser); _outputBus.Subscribe <SystemMessage.SystemStart>(storageChaser); _outputBus.Subscribe <SystemMessage.BecomeShuttingDown>(storageChaser); var storageScavenger = new StorageScavenger(db, readIndex); _outputBus.Subscribe <SystemMessage.ScavengeDatabase>(storageScavenger); //TCP var tcpService = new TcpService(MainQueue, _tcpEndPoint); Bus.Subscribe <SystemMessage.SystemInit>(tcpService); Bus.Subscribe <SystemMessage.SystemStart>(tcpService); Bus.Subscribe <SystemMessage.BecomeShuttingDown>(tcpService); //HTTP _httpService = new HttpService(ServiceAccessibility.Private, MainQueue, vNodeSettings.HttpPrefixes); Bus.Subscribe <SystemMessage.SystemInit>(HttpService); Bus.Subscribe <SystemMessage.BecomeShuttingDown>(HttpService); Bus.Subscribe <HttpMessage.SendOverHttp>(HttpService); Bus.Subscribe <HttpMessage.UpdatePendingRequests>(HttpService); HttpService.SetupController(new AdminController(MainQueue)); HttpService.SetupController(new PingController()); HttpService.SetupController(new StatController(monitoringQueue)); HttpService.SetupController(new ReadEventDataController(MainQueue)); HttpService.SetupController(new AtomController(MainQueue)); HttpService.SetupController(new WebSiteController(MainQueue)); //REQUEST MANAGEMENT var requestManagement = new RequestManagementService(MainQueue, 1, 1); Bus.Subscribe <StorageMessage.CreateStreamRequestCreated>(requestManagement); Bus.Subscribe <StorageMessage.WriteRequestCreated>(requestManagement); Bus.Subscribe <StorageMessage.TransactionStartRequestCreated>(requestManagement); Bus.Subscribe <StorageMessage.TransactionWriteRequestCreated>(requestManagement); Bus.Subscribe <StorageMessage.TransactionCommitRequestCreated>(requestManagement); Bus.Subscribe <StorageMessage.DeleteStreamRequestCreated>(requestManagement); Bus.Subscribe <StorageMessage.RequestCompleted>(requestManagement); Bus.Subscribe <StorageMessage.AlreadyCommitted>(requestManagement); Bus.Subscribe <StorageMessage.CommitAck>(requestManagement); Bus.Subscribe <StorageMessage.PrepareAck>(requestManagement); Bus.Subscribe <StorageMessage.WrongExpectedVersion>(requestManagement); Bus.Subscribe <StorageMessage.InvalidTransaction>(requestManagement); Bus.Subscribe <StorageMessage.StreamDeleted>(requestManagement); Bus.Subscribe <StorageMessage.PreparePhaseTimeout>(requestManagement); Bus.Subscribe <StorageMessage.CommitPhaseTimeout>(requestManagement); var clientService = new ClientService(); Bus.Subscribe <TcpMessage.ConnectionClosed>(clientService); Bus.Subscribe <ClientMessage.SubscribeToStream>(clientService); Bus.Subscribe <ClientMessage.UnsubscribeFromStream>(clientService); Bus.Subscribe <ClientMessage.SubscribeToAllStreams>(clientService); Bus.Subscribe <ClientMessage.UnsubscribeFromAllStreams>(clientService); Bus.Subscribe <StorageMessage.EventCommited>(clientService); //TIMER //var timer = new TimerService(new TimerBasedScheduler(new RealTimer(), new RealTimeProvider())); _timerService = new TimerService(new ThreadBasedScheduler(new RealTimeProvider())); Bus.Subscribe <TimerMessage.Schedule>(TimerService); MainQueue.Start(); monitoringQueue.Start(); }
public AbstractROMTest() { this.bus = new Bus(); this.cpu = bus.GetCPU(); }
public Result Initialize(RunDescriptor run, EndpointBehavior endpointBehavior, IDictionary <Type, string> routingTable, string endpointName) { try { runDescriptor = run; behavior = endpointBehavior; scenarioContext = run.ScenarioContext; configuration = ((IEndpointConfigurationFactory)Activator.CreateInstance(endpointBehavior.EndpointBuilderType)) .Get(); configuration.EndpointName = endpointName; if (!string.IsNullOrEmpty(configuration.CustomMachineName)) { RuntimeEnvironment.MachineNameAction = () => configuration.CustomMachineName; } //apply custom config settings var busConfiguration = configuration.GetConfiguration(run, routingTable); scenarioContext.ContextPropertyChanged += scenarioContext_ContextPropertyChanged; endpointBehavior.CustomConfig.ForEach(customAction => customAction(busConfiguration)); if (configuration.SendOnly) { sendOnlyBus = Bus.CreateSendOnly(busConfiguration); } else { bus = Bus.Create(busConfiguration); var transportDefinition = ((UnicastBus)bus).Settings.Get <TransportDefinition>(); scenarioContext.HasNativePubSubSupport = transportDefinition.HasNativePubSubSupport; } executeWhens = Task.Factory.StartNew(() => { while (!stopped) { //we spin around each 5s since the callback mechanism seems to be shaky contextChanged.Wait(TimeSpan.FromSeconds(5)); lock (behavior) { foreach (var when in behavior.Whens) { if (executedWhens.Contains(when.Id)) { continue; } if (when.ExecuteAction(scenarioContext, bus)) { executedWhens.Add(when.Id); } } } } }); return(Result.Success()); } catch (Exception ex) { Logger.Error("Failed to initialize endpoint " + endpointName, ex); return(Result.Failure(ex)); } }
public ButtonInterrupt(uint baseAddress, uint size, Bus addressBus, Bus dataBus, string name) : base(baseAddress, size, addressBus, dataBus, name) { }
public Customer(Bus bus, Waiter water, Cashier cashier) { _bus = bus; _water = water; _cashier = cashier; }
public AlarmClock(Bus bus) { _bus = bus; }
protected LittleEndianProcessor(Bus memory) : base(memory) { }
public FOGSystemService() : base() { Bus.SetMode(Bus.Mode.Server); }
static void Main(string[] args) { //First set of test code var tollCalc = new TollCalculator(); var car = new Car(); var taxi = new Taxi(); var bus = new Bus(); var truck = new DeliveryTruck(); Console.WriteLine($"The toll for a car is {tollCalc.CalculateToll(car)}"); Console.WriteLine($"The toll for a taxi is {tollCalc.CalculateToll(taxi)}"); Console.WriteLine($"The toll for a bus is {tollCalc.CalculateToll(bus)}"); Console.WriteLine($"The toll for a truck is {tollCalc.CalculateToll(truck)}"); try { tollCalc.CalculateToll("this will fail"); } catch (ArgumentException e) { Console.WriteLine("Caught an argument exception when using the wrong type"); } try { tollCalc.CalculateToll(null !); } catch (ArgumentNullException e) { Console.WriteLine("Caught an argument exception when using null"); } /* 2nd test (after adding for occupants) * var tollCalc = new TollCalculator(); * var soloDriver = new Car(); * var twoRideShare = new Car { Passengers = 1 }; * var threeRideShare = new Car { Passengers = 2 }; * var fullVan = new Car { Passengers = 5 }; * var emptyTaxi = new Taxi(); * var singleFare = new Taxi { Fares = 1 }; * var doubleFare = new Taxi { Fares = 2 }; * var fullVanPool = new Taxi { Fares = 5 }; * var lowOccupantBus = new Bus { Capacity = 90, Riders = 15 }; * var normalBus = new Bus { Capacity = 90, Riders = 75 }; * var fullBus = new Bus { Capacity = 90, Riders = 85 }; * var heavyTruck = new DeliveryTruck { GrossWeightClass = 7500 }; * var truck = new DeliveryTruck { GrossWeightClass = 4000 }; * var lightTruck = new DeliveryTruck { GrossWeightClass = 2500 }; * Console.WriteLine($"The toll for a solo driver is {tollCalc.CalculateToll(soloDriver)}"); * Console.WriteLine($"The toll for a two ride share is {tollCalc.CalculateToll(twoRideShare)}"); * Console.WriteLine($"The toll for a three ride share is {tollCalc.CalculateToll(threeRideShare)}"); * Console.WriteLine($"The toll for a fullVan is {tollCalc.CalculateToll(fullVan)}"); * Console.WriteLine($"The toll for an empty taxi is {tollCalc.CalculateToll(emptyTaxi)}"); * Console.WriteLine($"The toll for a single fare taxi is {tollCalc.CalculateToll(singleFare)}"); * Console.WriteLine($"The toll for a double fare taxi is {tollCalc.CalculateToll(doubleFare)}"); * Console.WriteLine($"The toll for a full van taxi is {tollCalc.CalculateToll(fullVanPool)}"); * Console.WriteLine($"The toll for a low-occupant bus is {tollCalc.CalculateToll(lowOccupantBus)}"); * Console.WriteLine($"The toll for a regular bus is {tollCalc.CalculateToll(normalBus)}"); * Console.WriteLine($"The toll for a bus is {tollCalc.CalculateToll(fullBus)}"); * Console.WriteLine($"The toll for a truck is {tollCalc.CalculateToll(heavyTruck)}"); * Console.WriteLine($"The toll for a truck is {tollCalc.CalculateToll(truck)}"); * Console.WriteLine($"The toll for a truck is {tollCalc.CalculateToll(lightTruck)}"); * try * { * tollCalc.CalculateToll("this will fail"); * } * catch (ArgumentException e) * { * Console.WriteLine("Caught an argument exception when using the wrong type"); * } * try * { * tollCalc.CalculateToll(null); * } * catch (ArgumentNullException e) * { * Console.WriteLine("Caught an argument exception when using null"); * } */ /* * Console.WriteLine("Testing the time premiums"); * var testTimes = new DateTime[] * { * new DateTime(2019, 3, 4, 8, 0, 0), // morning rush * new DateTime(2019, 3, 6, 11, 30, 0), // daytime * new DateTime(2019, 3, 7, 17, 15, 0), // evening rush * new DateTime(2019, 3, 14, 03, 30, 0), // overnight * new DateTime(2019, 3, 16, 8, 30, 0), // weekend morning rush * new DateTime(2019, 3, 17, 14, 30, 0), // weekend daytime * new DateTime(2019, 3, 17, 18, 05, 0), // weekend evening rush * new DateTime(2019, 3, 16, 01, 30, 0), // weekend overnight * }; * foreach (var time in testTimes) * { * Console.WriteLine($"Inbound premium at {time} is {tollCalc.PeakTimePremiumFull(time, true)}"); * Console.WriteLine($"Outbound premium at {time} is {tollCalc.PeakTimePremiumFull(time, false)}"); * } * Console.WriteLine("===================================================="); * foreach (var time in testTimes) * { * Console.WriteLine($"Inbound premium at {time} is {tollCalc.PeakTimePremium(time, true)}"); * Console.WriteLine($"Outbound premium at {time} is {tollCalc.PeakTimePremium(time, false)}"); * } */ }
public override void Execute(CPUState state, Bus bus) { int effectiveAddress = CalculateEffectiveAddress(state, bus); bus.Write(effectiveAddress, state.RegisterY); }
public void TheSubscriptionIsCreatedInEachRegion() { Bus.Received(2).AddNotificationSubscriber(Arg.Any <string>(), Arg.Any <INotificationSubscriber>()); }
public void HandlerIsAddedToBus() { Bus.Received().AddMessageHandler(Arg.Any <string>(), Arg.Any <string>(), Arg.Any <Func <IHandlerAsync <Message> > >()); }
public async Task Should_be_received() { await Bus.Publish(new SomethingHappened { Caption = "System Screw Up" }); await _observer.Received; }
public void Should_return_a_wonderful_breakdown_of_the_guts_inside_it() { var result = Bus.GetProbeResult(); Console.WriteLine(result.ToJsonString()); }
public void Handle(Message1 message) { logger.Info("Hello from MySaga"); MarkAsComplete(); Bus.SendLocal(new Message2()); }
public TestCharacteristic(Bus bus, int index, ObjectPath service) : base(bus, index, testCharacteristicUUID, flags, service) { AddDescriptor(new TestDescriptor(bus, 0, GetPath())); data = new byte[0]; }
public void Handle(ShipOrderResponse message) { Bus.Publish <OrderShipped>(e => e.OrderId = Data.OrderId); MarkAsComplete(); }
public void Handle(StartSaga1Message message) { var sendFromSagaMessage = new SendFromSagaMessage(); Bus.SendLocal(sendFromSagaMessage); }