internal WaitThenClick(Driver driver, Options options, Waiter waiter, ElementFinder elementFinder)
: base(driver, options)
{
this.options = options;
this.waiter = waiter;
this.elementFinder = elementFinder;
}
public static void Main()
{
Cook joe = new Cook();
Waiter suzy = new Waiter(joe);
Customer fred = new Customer(suzy);
fred.PlaceOrder();
}
//INSERT
public void InsertWaiterInfo()
{
//The code that exists within this method is a standard CRUD insert.
//Similar to what was learned in APPDEV 1
eRestaurantController controller = new eRestaurantController();
//Load an instance of Waiter.
Waiter insertWaiter = new Waiter();
insertWaiter.WaiterID = 0;
insertWaiter.FirstName = FirstName.Text;
insertWaiter.LastName = LastName.Text;
insertWaiter.Phone = Phone.Text;
insertWaiter.Address = Address.Text;
insertWaiter.HireDate = DateTime.Parse(HiredDate.Text);
//Check if the release date is Null/Empty
if (string.IsNullOrEmpty(ReleaseDate.Text))
{
insertWaiter.ReleaseDate = null; //This can be null becuase in the database it is set to "Nullable"
}
else
{
insertWaiter.ReleaseDate = DateTime.Parse(ReleaseDate.Text);
}
//Add waiter to the database.
controller.Waiter_Add(insertWaiter);
//Rebind the dropdown (WaiterList) so the new entry will appear in the list.
WaiterList.DataBind();
}
protected void WaiterInsert_Click(object sender, EventArgs e)
{
//inline version of using MessageUserControl
MessageUserControl.TryRun(() =>
//remainder of the code is what would have gone in the external method of
//(processRequest(MethodName)
{
Waiter item = new Waiter();
item.FirstName = FirstName.Text;
item.LastName = LastName.Text;
item.Address = Address.Text;
item.Phone = Phone.Text;
item.HireDate = DateTime.Parse(HireDate.Text);
//nullable field
if(string.IsNullOrEmpty(ReleaseDate.Text))
{
item.ReleaseDate = null;
}
else
{
item.ReleaseDate = DateTime.Parse(ReleaseDate.Text);
}
AdminController SystemManager = new AdminController();
WaiterID.Text = SystemManager.Waiters_Add(item).ToString();
MessageUserControl.ShowInfo("Waiter added");
RefreshWaiterList(WaiterID.Text);
}
);
}
public void InsertWaiterInfo()
{
//the code that exists within this method
//is a standard CRUD insert which you learned in AppDev 1
eRestaurantController controller = new eRestaurantController();
//load an instance of Waiter
Waiter item = new Waiter();
item.WaiterID = 0; //identity field on SQL therefore set to 0
item.FirstName = FirstName.Text;
item.LastName = LastName.Text;
item.Phone = Phone.Text;
item.Address = Address.Text;
item.HireDate = DateTime.Parse(HiredDate.Text);
if (string.IsNullOrEmpty(ReleaseDate.Text))
{
item.ReleaseDate = null;
}
else
{
item.ReleaseDate = DateTime.Parse(ReleaseDate.Text);
}
//call the controller's Add method for the Waiter
controller.Waiter_Add(item);
//rebind the drop down list (WaiterList) so the new
//waiter will appear in the list
WaiterList.DataBind();
}
async Task<bool> wait(CancellationToken token)
{
Waiter<bool> waiter = null;
bool lockTaken = false;
try
{
spinner.Enter(ref lockTaken);
if (!this.IsLocked && this.waiters.Count == 0)
{
this.IsLocked = true;
return true;
}
waiter = new Waiter<bool>(token);
if (token != CancellationToken.None)
waiter.OnCancel += Waiter_OnCancel;
waiters.InsertAtTail(waiter);
}
finally
{
if (lockTaken)
spinner.Exit(false);
}
if (waiter == null)
return false;
bool hasLock = await waiter;
token.ThrowIfCancellationRequested();
return hasLock;
}
public async Task<Dictionary<string, string>> Get([FromUri] int ms)
{
//Sanitize
ms = ms > 2000 ? 1 : ms;
var waiting = new Waiter();
var stopwatch = new Stopwatch();
stopwatch.Start();
stopwatch.Restart();
waiting.DoWork(ms);
var inOrderSpan = stopwatch.Elapsed;
stopwatch.Restart();
await waiting.DoWorkAsync(ms);
var asyncSpan = stopwatch.Elapsed;
var returnDictionary = new Dictionary<string, string>
{
{"processors", Environment.ProcessorCount.ToString()},
{"inOrderSpan", inOrderSpan.ToString()},
{"asyncSpan", asyncSpan.ToString()}
};
var results = JsonConvert.SerializeObject(returnDictionary);
LogManager.GetCurrentClassLogger().Log(LogLevel.Info, results);
return returnDictionary;
}
internal static async Task<string> Input(ConsoleControl.ConsoleControl cons)
{
using (var waitr = new Waiter(cons))
{
await waitr.Completion.Task;
return waitr.Content;
}
}
internal WaitThenClick(Driver driver, Options options, Waiter waiter, ElementFinder elementFinder, DisambiguationStrategy disambiguationStrategy)
: base(driver, options)
{
waitBeforeClick = options.WaitBeforeClick;
this.waiter = waiter;
this.elementFinder = elementFinder;
this.disambiguationStrategy = disambiguationStrategy;
}
private static Waiter GetWaiterForCurrentThread()
{
Waiter waiter = t_waiterForCurrentThread;
if (waiter == null)
waiter = t_waiterForCurrentThread = new Waiter();
waiter.signalled = false;
return waiter;
}
private unsafe void AssertIsNotInList(Waiter waiter)
{
Contract.Assert(waiter.next == null && waiter.prev == null);
Contract.Assert((_waitersHead == null) == (_waitersTail == null));
for (Waiter current = _waitersHead; current != null; current = current.next)
if (current == waiter)
Contract.Assert(false, "Waiter is in the waiter list, but should not be");
}
public void AddWaitersScenerio()
{
Waiter newGuy = new Waiter();
int waiterId = -1;
this.Given(_=>GiveWaiterInformation(newGuy))
.when(_=>WhenIAddTheWaiter(newGuy, out waitId))
.then(_=>ThenTheWaiterExists(waiterId))
.And(_=>TheWaiterDetailsMatch(waiterId, newGuy))
.BDDfy
public void MakeBurger(Waiter waiter)
{
if (burgers > 0) {
Console.WriteLine("Cook making Burger");
waiter.ServeFood("Burger");
burgers--;
}
else
Console.WriteLine("Sorry -- No more Burgers");
}
public void MakeFries(Waiter waiter)
{
if (fries > 0) {
Console.WriteLine("Cook making Fries");
waiter.ServeFood("Fries");
fries--;
}
else
Console.WriteLine("Sorry -- No more Fries");
}
private unsafe void AssertIsInList(Waiter waiter)
{
Contract.Assert(_waitersHead != null && _waitersTail != null);
Contract.Assert((_waitersHead == waiter) == (waiter.prev == null));
Contract.Assert((_waitersTail == waiter) == (waiter.next == null));
for (Waiter current = _waitersHead; current != null; current = current.next)
if (current == waiter)
return;
Contract.Assert(false, "Waiter is not in the waiter list");
}
internal static async Task<AutomationEventArgs> Event(
AutomationEvent eventId,
AutomationElement element = null,
TreeScope scope = TreeScope.Descendants)
{
using (var waitr = new Waiter(eventId, element, scope))
{
await waitr.Completion.Task;
return waitr.EvtArgs;
}
}
public void CheckOrderTest()
{
IMessageSource<TestMessage> source = MessageGenerator.CreateSource(TestRouterHelper.SourceName, TestRouterHelper.MessagesCountToGenerate);
var waiter = new Waiter(waitablesCount:1);
var factory = new TestRouterFactory(waiter, messages => messages.CheckOrder(TestRouterHelper.Sequence(0, TestRouterHelper.MessagesCountToGenerate)));
using(IMessageConsumer<TestMessage> consumer = factory.CreateConsumer(source))
{
consumer.Consume(TestRouterHelper.HandleMessage);
waiter.Wait(true);
}
}
public void SwallowExceptionTest()
{
const int errorMessageIndex = 5;
var waiter = new Waiter(waitablesCount:1);
IMessageSource<TestMessage> source = MessageGenerator.CreateSource(TestRouterHelper.SourceName, TestRouterHelper.MessagesCountToGenerate, errorMessageIndex, swallowException:true);
var factory = new TestRouterFactory(waiter, messages => messages.CheckOrder(TestRouterHelper.SequenceExcluding(0, TestRouterHelper.MessagesCountToGenerate, errorMessageIndex)));
using (IMessageConsumer<TestMessage> consumer = factory.CreateConsumer(source))
{
consumer.Consume(TestRouterHelper.HandleMessage);
waiter.Wait(true);
}
}
public void Test()
{
var waiter = new Waiter();
waiter.Start();
Console.WriteLine("Waiter started");
Thread.Sleep(5000);
waiter.Stop();
Console.WriteLine("Waiter stopped");
}
static void Main(string[] args)
{
Barbecuer boy = new Barbecuer();
Command bakeMutton1 = new BakeMuttonCommand(boy);
Command bakeMutton2 = new BakeMuttonCommand(boy);
Command bakeChickenWing = new BakeChickenWingCommand(boy);
Waiter girl = new Waiter();
girl.SetOrder(bakeMutton1);
girl.SetOrder(bakeMutton2);
girl.SetOrder(bakeChickenWing);
girl.Notify();
}
public void CheckIsRunningTest()
{
IMessageSource<TestMessage> source = MessageGenerator.CreateSource(TestRouterHelper.SourceName, TestRouterHelper.MessagesCountToGenerate);
var waiter = new Waiter(waitablesCount:1);
var factory = new TestRouterFactory(waiter, messages =>{});
using (IMessageConsumer<TestMessage> consumer = factory.CreateConsumer(source))
{
consumer.IsRunning.Should(Be.False, "consumer.IsRunning.Should(Be.False)");
consumer.Consume(TestRouterHelper.HandleMessage);
consumer.IsRunning.Should(Be.True, "consumer.IsRunning.Should(Be.True)");
waiter.Wait();
consumer.IsRunning.Should(Be.True, "consumer.IsRunning.Should(Be.True)");
}
}
private unsafe void AddWaiter(Waiter waiter)
{
Contract.Assert(_lock.IsAcquired);
AssertIsNotInList(waiter);
waiter.prev = _waitersTail;
if (waiter.prev != null)
waiter.prev.next = waiter;
_waitersTail = waiter;
if (_waitersHead == null)
_waitersHead = waiter;
}
public void ChildrenOrderTest()
{
const int sourcesCount = 5;
IMessageSource<TestMessage> source = MessageGenerator.CreateCompositeSource(TestRouterHelper.SourceName, sourcesCount, TestRouterHelper.MessagesCountToGenerate);
var waiter = new Waiter(sourcesCount);
var factory = new TestRouterFactory(waiter, messages => messages.CheckOrder(TestRouterHelper.Sequence(0, TestRouterHelper.MessagesCountToGenerate)));
using (IMessageConsumer<TestMessage> router = factory.CreateRouter(source, factory, m => m.Tag))
{
router.Consume(TestRouterHelper.HandleMessage);
waiter.Wait(true);
// we compare to 55, not 50, because each source has stop message at the end.
((TestMessageRouter) router).ReceiveCallCount.Should(Be.EqualTo(55));
}
}
private void Waiter_OnCancel(Waiter<bool> w)
{
bool spinTaken = false;
try
{
spinner.Enter(ref spinTaken);
waiters.Remove(w);
}
finally
{
if (spinTaken)
spinner.Exit(false);
}
w.Completed(false);
}
public void AddWaiter()
{
Waiter person = new Waiter()
{
FirstName = FirstName.Text,
LastName = LastName.Text,
Address = Address.Text,
Phone = Phone.Text,
HireDate = DateTime.Parse(HireDate.Text)
};
DateTime temp;
if (DateTime.TryParse(ReleaseDate.Text, out temp))
person.ReleaseDate = temp;
var controller = new RestaurantAdminController();
person.WaiterID = controller.AddWaiter(person);
WaiterID.Text = person.WaiterID.ToString();
}
public bool Wait(int milliseconds)
{
Waiter waiter;
lock (_syncRoot)
{
if (_tokens > 0)
{
--_tokens;
return true;
}
waiter = new Waiter();
_waitQueue.Enqueue(waiter);
}
return waiter.TryWait(milliseconds);
}
private unsafe void RemoveWaiter(Waiter waiter)
{
Contract.Assert(_lock.IsAcquired);
AssertIsInList(waiter);
if (waiter.next != null)
waiter.next.prev = waiter.prev;
else
_waitersTail = waiter.prev;
if (waiter.prev != null)
waiter.prev.next = waiter.next;
else
_waitersHead = waiter.next;
waiter.next = null;
waiter.prev = null;
}
protected void InsertWaiter_Click(object sender, EventArgs e)
{
//this example is using the TryRun inline
MessageUserControl1.TryRun(() =>
{
Waiter item = new Waiter();
item.FirstName = FirstName.Text;
item.LastName = LastName.Text;
item.Address = Address.Text;
item.Phone = Phone.Text;
item.HireDate = DateTime.Parse(DateHired.Text);
item.ReleaseDate = null;
AdminController sysmgr = new AdminController();
WaiterID.Text = sysmgr.Waiter_Add(item).ToString();
MessageUserControl1.ShowInfo("Waiter Added.");
RefreshWaiterList(WaiterID.Text);
});
}
internal static BrowserSession Build(SessionConfiguration sessionConfiguration,
Driver driver,
TimingStrategy timingStrategy,
Waiter waiter,
RestrictedResourceDownloader restrictedResourceDownloader,
UrlBuilder urlBuilder,
DisambiguationStrategy disambiguationStrategy = null)
{
disambiguationStrategy = disambiguationStrategy ?? new FirstOrDefaultNoDisambiguationStrategy();
return new BrowserSession(sessionConfiguration,
new StubDriverFactory(driver),
timingStrategy,
waiter,
urlBuilder,
disambiguationStrategy,
restrictedResourceDownloader);
}
public void RouterShouldHandleMessagesIfTagIsNotProvided()
{
IMessageSource<TestMessage> source = MessageGenerator.CreateSource(string.Empty, 5);
var waiter = new Waiter(1);
var factory = new TestRouterFactory(waiter, messages => { });
using (IMessageConsumer<TestMessage> router = factory.CreateRouter(source, factory, m => m.Tag))
{
var messagesHandled = 0;
waiter.Register(router);
router.While = m => TestMessage.IsNotStopMessage(string.Empty, m);
router.Consume(message => messagesHandled++);
waiter.Wait(true);
messagesHandled.Should(Be.EqualTo(6));
//Do not receive message from queue, if router handles message by itself. Let the handle logic do this.
((TestMessageRouter)router).ReceiveCallCount.Should(Be.EqualTo(0));
}
}
public void Wait_Throws_And_Is_Dequeued_When_Thrown()
{
var key = new WaitKey(MessageCode.Server.Login);
using (var waiter = new Waiter(0))
{
Task <object> task = waiter.Wait <object>(key, 999999);
object result = null;
waiter.Throw(key, new InvalidOperationException("error"));
var ex = Record.Exception(() => result = task.Result);
var waits = waiter.GetProperty <ConcurrentDictionary <WaitKey, ConcurrentQueue <PendingWait> > >("Waits");
Assert.NotNull(ex);
Assert.IsType <InvalidOperationException>(ex.InnerException);
Assert.Equal("error", ex.InnerException.Message);
Assert.False(waits.TryGetValue(key, out _));
}
}
public bool LogOn(string username, string password)
{
this.driver.FindElement(By.CssSelector(".auth-bar__item--text")).Click();
Waiter.WaitDocumentCompleteState(this.driver);
IWebElement usernameElement = this.driver.FindElement(By.XPath("//input[@data-field='login' and @type='text']"));
IWebElement passwordElement = this.driver.FindElement(By.XPath("//input[@data-field='login' and @type='password']"));
usernameElement.Clear();
usernameElement.SendKeys(username);
passwordElement.Clear();
passwordElement.SendKeys(password);
this.driver.FindElement(By.CssSelector("button.auth-box__auth-submit")).Click();
Waiter.WaitDocumentCompleteState(this.driver);
if (this.driver.FindElements(By.XPath("//div[@id='auth-container']")).Count > 0)
{
this.driver.FindElement(By.CssSelector(".modal-close")).Click();
return(false);
}
driver.SwitchTo().Window(driver.WindowHandles.Last());
return(true);
}
static void Main(string[] args)
{
try
{
ApplicationMode.Instance.DisplayOption = FileMessage.Instance;
User u = new User();
Receptioner receptioner = new Receptioner();
User client = receptioner.GreetClient();
if (client != null)
{
var waiter = new Waiter();
System.Console.WriteLine("<<Waiter arrives>>");
waiter.GetUserOption(client);
}
}catch
{
}
}
private Process StartProcess()
{
var process = new Process
{
StartInfo = new ProcessStartInfo
{
FileName = "/bin/bash",
Arguments = "-c \"sleep infinity \"",
RedirectStandardError = true,
RedirectStandardOutput = true,
UseShellExecute = false,
CreateNoWindow = true
},
EnableRaisingEvents = true
};
process.Start();
process.StandardError.ReadLineAsync().ContinueWith(t => _testOutput.WriteLine(t.Result));
Waiter.Wait(() => Linux.ProcessManager.GetProcessInfoById(process.Id) != null, TimeSpan.FromSeconds(2));
return(process);
}
protected void WaiterUpdate_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(IDLabel.Text))
{
MessageUserControl.ShowInfo("Please select a waiter first before updating.");
}
else
{
//standard update process
MessageUserControl.TryRun
(
() =>
//remainder of the code is waht would have gone in the
//external method of (processRequest(MethodNum))
{
Waiter item = new Waiter();
item.WaiterID = int.Parse(IDLabel.Text);
item.FirstName = FirstNameTextBox.Text;
item.LastName = LastNameTextBox.Text;
item.Address = AddressTextBox.Text;
item.Phone = PhoneTextBox.Text;
item.HireDate = DateTime.Parse(HireDateTextBox.Text);
if (string.IsNullOrEmpty(ReleaseDateTextBox.Text))
{
item.ReleaseDate = null;
}
else
{
item.ReleaseDate = DateTime.Parse(ReleaseDateTextBox.Text);
}
AdminController sysmgr = new AdminController();
sysmgr.Waiter_Update(item);
MessageUserControl.ShowInfo("Waiter updated.");
RefreshWaiterList(IDLabel.Text);
}
);
}
}
public async Task TestCreateWithBufferNotInWorkspace()
{
// don't crash
using (var workspace = await CSharpWorkspaceFactory.CreateWorkspaceFromFileAsync(""))
{
var document = workspace.CurrentSolution.GetDocument(workspace.Documents.First().Id);
var contentTypeService = document.GetLanguageService <IContentTypeLanguageService>();
var contentType = contentTypeService.GetDefaultContentType();
var extraBuffer = workspace.ExportProvider.GetExportedValue <ITextBufferFactoryService>().CreateTextBuffer("", contentType);
WpfTestCase.RequireWpfFact("Creates an IWpfTextView explicitly with an unrelated buffer");
using (var disposableView = workspace.ExportProvider.GetExportedValue <ITextEditorFactoryService>().CreateDisposableTextView(extraBuffer))
{
var waiter = new Waiter();
var provider = new SemanticClassificationViewTaggerProvider(
workspace.ExportProvider.GetExportedValue <IForegroundNotificationService>(),
workspace.ExportProvider.GetExportedValue <ISemanticChangeNotificationService>(),
workspace.ExportProvider.GetExportedValue <ClassificationTypeMap>(),
SpecializedCollections.SingletonEnumerable(
new Lazy <IAsynchronousOperationListener, FeatureMetadata>(
() => waiter, new FeatureMetadata(new Dictionary <string, object>()
{
{ "FeatureName", FeatureAttribute.Classification }
}))));
using (var tagger = (IDisposable)provider.CreateTagger <IClassificationTag>(disposableView.TextView, extraBuffer))
{
using (var edit = extraBuffer.CreateEdit())
{
edit.Insert(0, "class A { }");
edit.Apply();
}
await waiter.CreateWaitTask();
}
}
}
}
private void button1_Click(object sender, EventArgs e)
{
Waiter w = new Waiter(this);
w.BeginWait();
Enabled = false;
try
{
metersList.CalculateGeneralCoeffs();
}
catch (Exception ex)
{
NotificationHelper.ShowError(ex.Message);
}
finally
{
Enabled = true;
w.EndWait();
}
}
public void StopMonitoring_EndOfIntervalCallbackNotCalledAfterwards()
{
// Arrange
WeatherMonitorStrategy target = new WeatherMonitorStrategy();
int callBackCount = 0;
target.StartMonitoring(TimeSpan.FromMilliseconds(200), () => callBackCount++);
// Act
Waiter.Until(() => callBackCount > 0);
target.StopMonitoring();
Waiter.Until(() =>
{
bool result = callBackCount == 0;
callBackCount = 0;
return(result);
});
// Assert
callBackCount.Should().Be(0);
}
protected void WaiterUpdate_Click(object sender, EventArgs e)
{
if (string.IsNullOrEmpty(WaiterID.Text))
{
MessageUserControl.ShowInfo("Please select a waiter first before updating.");
}
else
{
//standard update process
MessageUserControl.TryRun(() =>
//remainder of the code is what would have gone in the external
//method of (ProcessRequest(MethodName))
{
Waiter item = new Waiter();
//for an update you must supply the pkey value
item.WaiterID = int.Parse(WaiterID.Text);
item.FirstName = FirstName.Text;
item.LastName = LastName.Text;
item.Address = Address.Text;
item.Phone = Phone.Text;
item.HireDate = DateTime.Parse(HireDate.Text);
//what about nullable fields
if (string.IsNullOrEmpty(ReleaseDate.Text))
{
item.ReleaseDate = null;
}
else
{
item.ReleaseDate = DateTime.Parse(ReleaseDate.Text);
}
AdminController sysmgr = new AdminController();
sysmgr.waiter_Update(item);
MessageUserControl.ShowInfo("Waiter updated");//force drop down list to be refreshed
RefreshWaiterList(WaiterID.Text);
}
);
}
}
bool ValidateInteraction(Waiter waiter)
{
if (waiter.Follower)
{
return(false);
}
switch (State)
{
case CustomerState.WaitingToPlaceOrder:
{
return(true);
}
case CustomerState.WaitingForMeal:
{
return(waiter.Meal != null);
}
}
return(false);
}
public void Leave()
{
lock (syncRoot)
{
--referenceCount;
if (referenceCount == 0)
{
while (waiters.Count > 0)
{
Waiter waiter = waiters.Dequeue();
waiter.k.PostResult(true);
if (waiter.ctr.HasValue)
{
waiter.ctr.Value.Dispose();
}
}
}
}
}
public async Task Complete_Dequeues_Wait()
{
using (var waiter = new Waiter())
{
var result = Guid.NewGuid();
var task = waiter.Wait <Guid>(new WaitKey(MessageCode.ServerLogin));
waiter.Complete(new WaitKey(MessageCode.ServerLogin), result);
var waitResult = await task;
var key = new WaitKey(MessageCode.ServerLogin);
var waits = waiter.GetProperty <ConcurrentDictionary <WaitKey, ConcurrentQueue <PendingWait> > >("Waits");
waits.TryGetValue(key, out var queue);
var peek = queue.TryPeek(out var wait);
Assert.Equal(result, waitResult);
Assert.NotNull(queue);
Assert.Empty(queue);
Assert.False(peek);
}
}
bool ValidateInteraction(Waiter waiter)
{
if (waiter.Follower)
{
return(false);
}
switch (State)
{
case KitchenState.WaitingForOrder:
{
return(Customer.NumInState(CustomerState.PlacingOrder) > 0 || Customer.NumInState(CustomerState.WaitingForMeal) > 0);
}
case KitchenState.WaitingForCollection:
{
return(waiter.Meal == null);
}
}
return(false);
}
public int Waiter_Add(Waiter item)
{
//input into this method is at the instance level
using (eRestaurantContext context = new eRestaurantContext())
{
//create a pointer variable for the instance type
//set pointer to null
Waiter added = null;
//set up the add request for DBContext
added = context.Waiters.Add(item);
//saving the changes will cause .Add to execute
//commits the add to the database
//evaluates the annotations (validation) on your entity
context.SaveChanges();
//added contains the data of newly added waiter
//including pkey value
return(added.WaiterID);
}
}
private static Waiter SetUp(List <IStartable> startables, TopicBasedPubSub bus)
{
var reporter = new Reporter();
bus.SubscribeByType <OrderPaid>(reporter);
bus.SubscribeByType <OrderPlaced>(reporter);
var cashier = new ThreadedHandler <TakePayment>(new Cashier(bus), "Cashier");
startables.Add(cashier);
bus.SubscribeByType(cashier);
var assMan = new ThreadedHandler <PriceOrder>(new AssistantManager(bus), "Assistant Manager");
startables.Add(assMan);
bus.SubscribeByType(assMan);
var rnd = new Random(1234);
var cooks = Enumerable.Range(1, 3).Select(i =>
{
var cook = new ThreadedHandler <CookFood>(new Cook(bus, $"cook-{i}", rnd.Next(0, 1000)), "Cook " + i);
startables.Add(cook);
return(cook);
});
var alarm = new AlarmClock(bus);
bus.SubscribeByType(alarm);
startables.Add(alarm);
var dispatcher = new DroppingHandler <CookFood>(new MoreFairDispatcher <CookFood>(cooks));
bus.SubscribeByType(dispatcher);
var waiter = new Waiter(bus);
return(waiter);
}
private static void BackPressureTest()
{
var topicDispatcher = new TopicDispatcher();
var threadBoundaryMonitor = new ThreadBoundaryMonitor();
ThreadBoundary <Report> reporting = threadBoundaryMonitor.Wrap(new ReportingSystem(topicDispatcher));
var cashierInner = new Cashier(topicDispatcher);
ThreadBoundary <QueueOrderForPayment> cashier = threadBoundaryMonitor.Wrap(cashierInner);
ThreadBoundary <PriceFood> assManager = threadBoundaryMonitor.Wrap(new AssistantManager(topicDispatcher));
var cooks = new[]
{
threadBoundaryMonitor.Wrap(new Cook(topicDispatcher, 20)),
threadBoundaryMonitor.Wrap(new Cook(topicDispatcher, 50)),
threadBoundaryMonitor.Wrap(new Cook(topicDispatcher, 90))
};
TTLSettingHandler <CookFood> cookDispatcher =
TTLSettingHandler.Wrap(
threadBoundaryMonitor.Wrap(
RetryDispatcher.Wrap(
TTLFilteringHandler.Wrap(
SmartDispatcher.Wrap(cooks, 15)))),
10);
var waiter = new Waiter("Neil", topicDispatcher);
topicDispatcher.Subscribe(cashier);
topicDispatcher.Subscribe(cookDispatcher);
topicDispatcher.Subscribe(assManager);
topicDispatcher.Subscribe(reporting);
topicDispatcher.Subscribe(threadBoundaryMonitor.Wrap(new Logger()));
topicDispatcher.Subscribe(new SelfUnsubscribingOrderSampler(topicDispatcher));
topicDispatcher.Subscribe(threadBoundaryMonitor.Wrap <OrderTaken>(new OrderFulfillmentCoordinator(topicDispatcher)));
threadBoundaryMonitor.Start();
RunTest(waiter, cashierInner, 5000);
}
public async Task <ActionResult> Put(int id, [FromBody] Waiter waiter)
{
// If id in body does not match id in URL
if (id != waiter.User_ID)
{
return(BadRequest("id in URL has to match the id of the record to be updated\n"));
}
try
{
// Searching for record in the database
var response = await _repository.GetById(id);
if (response == null)
{
// If record does not exists
return(NotFound("Waiter record was not found\n"));
}
else
{
// If record was found modify it
await _repository.ModifyById(waiter);
string format = "Waiter record with key={0} was updated succesfully\n";
return(Ok(String.Format(format, id)));
}
}
catch (Npgsql.PostgresException ex)
{
// Postgres threw an exception
return(BadRequest(ex.Message.ToString()));
}
catch
{
// Unknown error
return(BadRequest("Error: Waiter record scould not be updated\n"));
}
}
/// <summary>
/// Wait for the latch to be released, blocking the current thread if necessary.
/// <para>
/// This method returns immediately if the latch has already been released.
/// </para>
/// </summary>
public virtual void Await()
{
// Put in a local variable to avoid volatile reads we don't need.
Node state = _stack;
if (state != _released)
{
// The latch hasn't obviously already been released, so we want to add a waiter to the stack. Trouble is,
// we might race with release here, so we need to re-check for release after we've modified the stack.
Waiter waiter = new Waiter();
state = ( Node )UnsafeUtil.getAndSetObject(this, _stackOffset, waiter);
if (state == _released)
{
// If we get 'released' back from the swap, then we raced with release, and it is our job to put the
// released sentinel back. Doing so can, however, return more waiters that have added themselves in
// the mean time. If we find such waiters, then we must make sure to unpark them. Note that we will
// never get a null back from this swap, because we at least added our own waiter earlier.
Node others = ( Node )UnsafeUtil.getAndSetObject(this, _stackOffset, _released);
// Set our next pointer to 'released' as a signal to other threads who might be going through the
// stack in the isReleased check.
waiter.Next = _released;
UnparkAll(others);
}
else
{
// It looks like the latch hasn't yet been released, so we are going to park. Before that, we must
// assign a non-null value to our next pointer, so other threads will know that we have been properly
// enqueued. We use the 'end' sentinel as a marker when there's otherwise no other next node.
waiter.Next = state == null ? _end : state;
do
{
// Park may wake up spuriously, so we have to loop on it until we observe from the state of the
// stack, that the latch has been released.
LockSupport.park(this);
} while (!IsReleased(waiter));
}
}
}
public void UpdateWaiter()
{
Waiter person = new Waiter()
{
WaiterID = int.Parse(WaiterID.Text),
FirstName = FirstName.Text,
LastName = LastName.Text,
Address = Address.Text,
Phone = Phone.Text,
HireDate = DateTime.Parse(HireDate.Text),
};
DateTime fireOn;
if (DateTime.TryParse(ReleaseDate.Text, out fireOn))
{
person.ReleaseDate = fireOn;
}
var controller = new RestaurantAdminController();
controller.UpdateWaiter(person);
//WaiterID.Text = person.WaiterID.ToString();
//TODO: Re-populate dropdown list of waiters and set the selectedvalue as well
}
void CustomersTakeSeats(Waiter waiter)
{
Customer customer = waiter.Follower.GetComponent <Customer>();
customer.MoveTarget = Chair0;
customer.StopFollowDistance = 0.05f;
customer.State = CustomerState.ConsideringOrder;
customer.table = this;
if (customer.PlusOne)
{
customer.PlusOne.MoveTarget = Chair1;
customer.PlusOne.StopFollowDistance = 0.05f;
customer.PlusOne.table = this;
}
waiter.Follower = null;
waiter.BeSeatedBubble.SetActive(true);
StartCoroutine(ShowBeSeated(waiter, 1.0f));
SetOccupied();
}
public object WaitTillPageLoad(IWebDriver webDriver, int waitTimeInSec)
{
try
{
Waiter.Wait(webDriver, waitTimeInSec == -1 ? appConfigMember.PageTimeout : waitTimeInSec).Until((driver) =>
{
try
{
return(((IJavaScriptExecutor)driver).ExecuteScript(JScriptType.PageLoad.GetDescription()).ToString().Contains("complete"));
}
catch (Exception ObjException)
{
Logger.Error(String.Format("Wait Till Page Load: Exception Thrown While Running JS Script.:{0}", ObjException.Message));
return(false);
}
});
}
catch (WebDriverTimeoutException ObjWebDriverTimeoutException)
{
Logger.Debug(String.Format("Wait Till Page Load: Exception Thrown While Running JS Script.:{0}", ObjWebDriverTimeoutException.Message));
}
return(false);
}
private void OnTriggerEnter2D(Collider2D collision)
{
if (collision.CompareTag("Table"))
{
Table table = collision.GetComponent <Table>();
tablesInRange.Add(table);
}
else if (collision.CompareTag("DishPickup"))
{
DishPickup pickup = collision.GetComponent <DishPickup>();
dishPickupsInRange.Add(pickup);
}
else if (collision.CompareTag("Waiter"))
{
Waiter waiter = collision.GetComponentInParent <Waiter>();
if (waiter == this)
{
return;
}
waitersInRange.Add(waiter);
// audioSC.PlayOneShot(collideSFX);
}
}
/// <summary>
/// wait for this task to finish
/// </summary>
public void Wait()
{
if (IsCompleted)
{
return;
}
var w = new Waiter();
OnComplete(w);
#if ECHOES
w.ev.WaitOne();
#elseif COOPER
lock (w.o) {
while (!w.done)
{
w.o.wait();
}
}
#else
w.ev.Wait();
#endif
w.Dispose();
}
public object Save([FromBody] Waiter waiter)
{
string sql = "";
if (waiter.Id > 0)
{
sql = $"UPDATE Waiter SET Name=@Name,WeiXinId=@WeiXinId,IsUsed=@IsUsed WHERE Id = @Id";
}
else
{
sql = $"INSERT INTO Waiter(WeiXinId, NAME, IsUsed) VALUES(@WeiXinId, @Name, @IsUsed)";
}
var xresult = new XResult();
if (!XDataHelper.ExcuteNonQuery(sql, waiter))
{
xresult.code = 10000;
xresult.message = "操作失败！";
}
;
return(xresult);
}
public string Login()
{
Console.WriteLine("Navigating to Login page");
_browser.Page.GoToUrl(Locate.URL);
// Step 1: find fields username and password
var username = _browser.Page.FindElement(By.Name(Locate.NAME_USERNAME));
var password = _browser.Page.FindElement(By.Name(Locate.NAME_PASSWORD));
_browser.Page.Write(username, "nvhung");
_browser.Page.Write(password, "nvhung");
Console.WriteLine("Step: Enter username and password");
var loginSubmit = _browser.Page.FindElement(By.ClassName("btn-default"));
loginSubmit.Click();
Console.WriteLine("Step: Click button Submit");
Waiter.WithTimeout(TimeSpan.FromSeconds(5));
var url = _browser.Page.Url;
return(url);
}
public IActionResult WaiterList()
{
OracleCommand cmd = DatabaseConnection.Connect().CreateCommand();
cmd.CommandText = "select * from Waiter_2_19";
List <Waiter> o = new List <Waiter>();
//execute the command and use datareader to display the data
OracleDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
Waiter i = new Waiter();
i.Waiter_id = Int32.Parse(reader.GetString(0));
i.Name = reader.GetString(1);
i.Address = reader.GetString(2);
i.Age = Int32.Parse(reader.GetString(3));
i.Experience = Int32.Parse(reader.GetString(4));
o.Add(i);
}
return(View(o));
}
private Task WaitInternal(Waiter waiter, bool createWaiter = false)
{
lock (this)
{
if (_IsSet)
{
if (_AutoReset)
{
_IsSet = false;
}
if (waiter != null)
{
waiter.TrySetComplete();
return(waiter.Task);
}
else
{
return(Task.CompletedTask);
}
}
if (createWaiter)
{
var w = new Waiter();
_Waiters.Enqueue(w);
return(w.Task);
}
if (waiter != null)
{
_Waiters.Enqueue(waiter);
}
return(null);
}
}
public bool UpdateWaiter(Waiter waiter)
{
SqlConnection sqlConnection = null;
bool successful;
sqlConnection = new SqlConnection(_sqlConnectionString);
SqlCommand sqlCommand = new SqlCommand();
sqlCommand.CommandType = CommandType.StoredProcedure;
sqlCommand.Connection = sqlConnection;
sqlCommand.CommandText = StoredProcedureNames.UpdateWaiter;
sqlCommand.Parameters.Add(new SqlParameter("@WaiterId", waiter.WaiterId));
sqlCommand.Parameters.Add(new SqlParameter("@FirstName", waiter.FirstName));
sqlCommand.Parameters.Add(new SqlParameter("@LastName", waiter.LastName));
sqlCommand.Parameters.Add(new SqlParameter("@Login", waiter.Login));
sqlCommand.Parameters.Add(new SqlParameter("@Password", waiter.Password));
try
{
sqlConnection.Open();
sqlCommand.ExecuteNonQuery();
successful = true;
}
finally
{
if (sqlConnection.State == ConnectionState.Open)
{
sqlConnection.Close();
}
}
return(successful);
}
private async Task RunConnect()
{
var ct = ProcessCancel.Token;
var taskSet = new HashSet <Task>();
var blockSize = (int)(Param.SamplingRate * Param.SampleLength);
Logger.LogInformation($"[loop3] blockSize {blockSize}");
var audioInterval = (long)(10_000_000.0 * Param.SampleLength);
Logger.LogInformation($"[loop3] audioInterval {audioInterval}");
var videoInterval = (long)(10_000_000.0 / Param.MaxFrameRate);
Logger.LogInformation($"[loop3] videoInterval {videoInterval}");
var counter = new ElapsedTimeCounter();
using var audioWaiter = new Waiter(counter, audioInterval);
using var videoWaiter = new Waiter(counter, videoInterval);
using var buf = new IPCBuffer <float>(Param.EffectName, blockSize * 2 * Param.BufferCount, LoggerFactory);
using var vstBufferPool = new BufferPool <VstBuffer2 <float> >(Param.BufferCount, () => new VstBuffer2 <float>(blockSize, 2, buf), LoggerFactory);
using var pcmPool = new BufferPool <PcmBuffer <float> >(Param.BufferCount, () => new PcmBuffer <float>(blockSize, 2), LoggerFactory);
using var audioPool = new BufferPool <OpusOutputBuffer>(Param.BufferCount, () => new OpusOutputBuffer(5000), LoggerFactory);
using var pcmDrowPool = new BufferPool <PcmBuffer <float> >(Param.BufferCount, () => new PcmBuffer <float>(blockSize, 2), LoggerFactory);
using var bmpPool = new BufferPool <H264InputBuffer>(Param.BufferCount, () => new H264InputBuffer(Param.Width, Param.Height), LoggerFactory);
using var videoPool = new BufferPool <H264OutputBuffer>(Param.BufferCount, () => new H264OutputBuffer(200000), LoggerFactory);
using var vst = new AudioMaster <float>(Param.SamplingRate, blockSize, LoggerFactory, counter, DllManager);
using var toPcm = new ToPcm <float>(LoggerFactory, counter);
using var opus = new OpusEncoder(SamplingRate.Sampling48000, Channels.Stereo, LoggerFactory, counter);
using var fft = new FFTEncoder(Param.Width, Param.Height, Param.MaxFrameRate, LoggerFactory, counter);
using var h264 = new H264Encoder(Param.Width, Param.Height, Param.TargetBitrate, Param.MaxFrameRate, LoggerFactory, counter);
effect = vst.AddEffect(Param.EffectName);
//effect.OpenEditor();
using var ftl = new FtlIngest(StreamKey, IngestHostname, LoggerFactory, counter, audioInterval, videoInterval, default, CaInfoPath);
public ValueTask <int> RequestCreditAsync(int amount, CancellationToken cancellationToken)
{
lock (SyncObject)
{
if (_disposed)
{
throw CreateObjectDisposedException(forActiveWaiter: false);
}
if (_current > 0)
{
Debug.Assert(_waiters == null || _waiters.Count == 0, "Shouldn't have waiters when credit is available");
int granted = Math.Min(amount, _current);
if (NetEventSource.IsEnabled)
{
_owner.Trace($"{_name}. requested={amount}, current={_current}, granted={granted}");
}
_current -= granted;
return(new ValueTask <int>(granted));
}
if (NetEventSource.IsEnabled)
{
_owner.Trace($"{_name}. requested={amount}, no credit available.");
}
var waiter = new Waiter {
Amount = amount
};
(_waiters ??= new Queue <Waiter>()).Enqueue(waiter);
return(cancellationToken.CanBeCanceled ?
waiter.WaitWithCancellationAsync(cancellationToken) :
new ValueTask <int>(waiter.Task));
}
}
