public void Color(IEgg egg, IBunny bunny) { if (bunny.Energy > 0) { bool isThereADyes = bunny.Dyes.Any(x => x.Power > 0); bool isEggFinished = false; if (isThereADyes) { foreach (var item in bunny.Dyes.Where(x => x.Power > 0)) { while (item.Power > 0 && !isEggFinished) { item.Use(); bunny.Work(); egg.GetColored(); isEggFinished = egg.IsDone(); if (isEggFinished) { break; } } if (isEggFinished) { break; } } } } }
static void Main(string[] args) { var pipe = Bunny.ConnectSingleWith(); IBunny bunny = pipe.Connect(); Console.ReadLine(); }
public async Task ConfirmsAndAcksWork() { IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp); IQueue queue = bunny.Setup() .Queue("constraint") .MaxLength(1) .QueueExpiry(1500) .Bind("amq.direct", "constraint-key") .OverflowReject(); bool isNacked = false; bool isAcked = false; var publisher = bunny.Publisher <TestMessage>("amq.direct"); Func <BasicNackEventArgs, Task> nacker = ea => { isNacked = true; return(Task.CompletedTask); }; Func <BasicAckEventArgs, Task> acker = ea => { isAcked = true; return(Task.CompletedTask); }; await publisher.WithQueueDeclare(queue) .WithConfirm(acker, nacker) .WithRoutingKey("constraint-key") .SendAsync(new TestMessage() { Text = "Confirm-1st" }); await publisher.WithQueueDeclare(queue) .WithConfirm(acker, nacker) .SendAsync(new TestMessage() { Text = "Confirm-2nd" }); Assert.True(isAcked); Assert.True(isNacked); bunny.Dispose(); }
public void Color(IEgg egg, IBunny bunny) { IDye dye = null; while (!egg.IsDone()) { if (dye == null || dye.IsFinished()) { dye = bunny.Dyes.FirstOrDefault(d => d.Power > 0); if (dye == null) { break; } } dye.Use(); bunny.Work(); egg.GetColored(); if (bunny.Energy == 0) { break; } } }
public void Color(IEgg egg, IBunny bunny) { if (bunny.Energy > 0 && bunny.Dyes.Any(d => d.Power > 0)) { while (!egg.IsDone()) { var usedDye = bunny.Dyes.FirstOrDefault(d => d.Power > 0); if (usedDye != null) { usedDye.Use(); egg.GetColored(); } else { var HasNewDay = bunny.Dyes.Any(d => d.Power > 0); if (HasNewDay) { var newDay = bunny.Dyes.First(d => d.Power > 0); newDay.Use(); egg.GetColored(); } else { bunny.Dyes.Remove(usedDye); break; } } if (bunny.Energy < 0 || bunny.Dyes.All(d => d.Power == 0)) { break; } } } }
public string ColorEgg(string eggName) { var readyBunnies = bunnies.Models.Where(b => b.Energy >= 50).OrderByDescending(b => b.Energy); var givenEgg = eggs.FindByName(eggName); if (readyBunnies == null) { throw new InvalidOperationException(ExceptionMessages.BunniesNotReady); } while (readyBunnies != null && !givenEgg.IsDone()) { IBunny workingBunny = readyBunnies.First(); givenEgg.GetColored(); workingBunny.Work(); if (workingBunny.Energy == 0) { bunnies.Remove(workingBunny); } readyBunnies = bunnies.Models.Where(b => b.Energy >= 50).OrderByDescending(b => b.Energy); } var status = givenEgg.IsDone() ? "done" : "not done"; return($"Egg {eggName} is {status}."); }
public void Color(IEgg egg, IBunny bunny) { bool finishColoring = false; while (!egg.IsDone() && bunny.Energy > 0 && bunny.Dyes.Any(d => !d.IsFinished())) { foreach (IDye dye in bunny.Dyes.Where(d => !d.IsFinished())) { if (finishColoring) { break; } while (true) { egg.GetColored(); dye.Use(); bunny.Work(); if (egg.IsDone() || bunny.Energy == 0) { finishColoring = true; break; } if (dye.IsFinished()) { break; } } } } }
public string ColorEgg(string eggName) { IEgg eggToColor = eggs.FindByName(eggName); List <IBunny> orderderBunnies = bunnies.Models.OrderByDescending(x => x.Energy).Where(y => y.Energy >= 50).ToList(); if (orderderBunnies.Count() == 0) { throw new InvalidOperationException(ExceptionMessages.BunniesNotReady); } for (int i = 0; i < orderderBunnies.Count(); i++) { IBunny currentBunny = orderderBunnies[i]; worshop.Color(eggToColor, currentBunny); if (eggToColor.IsDone()) { break; } if (currentBunny.Energy <= 0) { orderderBunnies.Remove(currentBunny); bunnies.Remove(currentBunny); i--; } } if (eggToColor.IsDone()) { return(String.Format(OutputMessages.EggIsDone, eggName)); } else { //return OutputMessages.EggIsNotDone return(String.Format(OutputMessages.EggIsNotDone, eggName)); } }
internal DeclarePublisher(IBunny bunny, string publishTo) { _bunny = bunny; _publishTo = publishTo; _serialize = Config.Serialize; _thisChannel = new PermanentChannel(bunny); }
public void Color(IEgg egg, IBunny bunny) { while (bunny.Energy > 0 && bunny.Dyes.Any()) { var dye = bunny.Dyes.FirstOrDefault(x => !x.IsFinished()); while (!dye.IsFinished() && !egg.IsDone()) { bunny.Work(); dye.Use(); egg.GetColored(); if (bunny.Energy == 0) { break; } } if (dye.IsFinished()) { bunny.Dyes.Remove(dye); } if (egg.IsDone()) { break; } } }
public void Color(IEgg egg, IBunny bunny) { foreach (var dye in bunny.Dyes) { while (!dye.IsFinished()) { if (bunny.Energy == 0) { break; } egg.GetColored(); bunny.Work(); dye.Use(); if (egg.IsDone()) { break; } } if (egg.IsDone()) { break; } } }
public string AddBunny(string bunnyType, string bunnyName) { IBunny bunny = null; string message = string.Empty; switch (bunnyType) { case "HappyBunny": bunny = new HappyBunny(bunnyName); bunnyRepository.Add(bunny); message = string.Format(OutputMessages.BunnyAdded, bunnyType, bunnyName); break; case "SleepyBunny": bunny = new SleepyBunny(bunnyName); bunnyRepository.Add(bunny); message = string.Format(OutputMessages.BunnyAdded, bunnyType, bunnyName); break; default: message = ExceptionMessages.InvalidBunnyType; break; } return(message); }
///<summary> /// Interface for building Queues, Exchanges, Bindings and so on ///</summary> public static IDeclare Setup(this IBunny bunny) { return(new DeclareBase() { Bunny = bunny }); }
public void Color(IEgg egg, IBunny bunny) { var dyes = bunny.Dyes; foreach (var dye in dyes) { while (!egg.IsDone()) { if (bunny.Energy > 0 && !dye.IsFinished()) { dye.Use(); bunny.Work(); egg.GetColored(); } else { break; } } if (egg.IsDone() || bunny.Energy <= 0) { break; } } }
public async Task GetReturnsOperationResultFailIfNoMessages() { IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp); var opResult = await bunny.Consumer <ConsumeMessage>(get).AsAutoAck().GetAsync(carrot => Task.CompletedTask); Assert.NotNull(opResult); Assert.Equal(OperationState.GetFailed, opResult.State); }
public void ConnectToSingleNodeWithConnectionPipe() { var pipe = Bunny.ConnectSingleWith(); // not configuring anything uses default IBunny bunny = pipe.Connect(); Assert.NotNull(bunny); }
///<summary> /// Create a Consumer to subscribe to a Queue. If no queue is specified the Queue Name will be AssemblyName.TypeName ///</summary> public static IConsume <TMsg> Consumer <TMsg>(this IBunny bunny, string fromQueue = null) { if (fromQueue == null) { fromQueue = SerializeTypeName <TMsg>(); } return(new DeclareConsumer <TMsg>(bunny, fromQueue)); }
public DeclareConsumer(IBunny bunny, string fromQueue) { _bunny = bunny; _deserialize = Config.Deserialize <TMsg>; _consumeFromQueue = fromQueue; _thisChannel = new PermanentChannel(bunny); _receive = async carrot => await carrot.SendAckAsync(); }
internal DeclareRequest(IBunny bunny, string toExchange, string routingKey) { _bunny = bunny; _toExchange = toExchange; _routingKey = routingKey; _serialize = Config.Serialize; _deserialize = Config.Deserialize <TResponse>; _thisChannel = new PermanentChannel(_bunny); }
public async Task PublisherSimplySendsWithoutQueueReturnsFailure() { IBunny bunny = Bunny.ConnectSingle(ConnectSimple.BasicAmqp); IPublish <TestMessage> publisher = bunny.Publisher <TestMessage>(Exchange); OperationResult <TestMessage> result = await publisher.SendAsync(new TestMessage()); Assert.True(result.IsSuccess); bunny.Dispose(); }
///<summary> /// Create a Requester to send Rpc Requests. If no routingKey is specified the routingKey will be AssemblyName.TypeName ///</summary> public static IRequest <TRequest, TResponse> Request <TRequest, TResponse>(this IBunny bunny, string rpcExchange, string routingKey = null) where TRequest : class where TResponse : class { if (routingKey == null) { routingKey = SerializeTypeName <TRequest>(); } return(new DeclareRequest <TRequest, TResponse>(bunny, rpcExchange, routingKey)); }
///<summary> /// Enter Queue DeclarationMode ///</summary> public static IQueue Queue(this IDeclare declare, string name) { if ((declare is DeclareBase) == false) { throw DeclarationException.WrongType(typeof(DeclareBase), declare); } IBunny bunny = CheckGetBunny(declare, name, "queue"); return(new DeclareQueue(bunny, name)); }
///<summary> /// Other side of the Rpc Call. Consumes fromQueue. If not Specified does consume from AssemblyName.TypeName ///</summary> public static IRespond <TRequest, TResponse> Respond <TRequest, TResponse>(this IBunny bunny, string rpcExchange , Func <TRequest, Task <TResponse> > respond, string fromQueue = null) where TRequest : class where TResponse : class { if (fromQueue == null) { fromQueue = SerializeTypeName <TRequest>(); } return(new DeclareResponder <TRequest, TResponse>(bunny, rpcExchange, fromQueue, respond)); }
private void SetupAndPublish(IBunny bunny, string queueName = queue) { var msg = new ConsumeMessage(); var bytes = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(msg)); var channel = bunny.Channel(newOne: true); var prop = channel.CreateBasicProperties(); prop.Persistent = true; channel.BasicPublish("", queueName, false, prop, bytes); }
public void Color(IEgg egg, IBunny bunny) ///problemmm { while (egg.IsDone() == false && bunny.Energy > 0 && bunny.Dyes.Any(x => x.IsFinished() == false)) { egg.GetColored(); bunny.Work(); IDye dye = bunny.Dyes.FirstOrDefault(x => x.IsFinished() == false); dye.Use(); } }
public void Color(IEgg egg, IBunny bunny) { while (true) { if (bunny.Energy == 0) { break; } if (bunny.Dyes.All(x => x.IsFinished())) { break; } egg.GetColored(); bunny.Work(); while (bunny.Dyes.Any()) { if (bunny.Dyes.First().IsFinished() == false) { bunny.Dyes.First().Use(); break; } bunny.Dyes.Remove(bunny.Dyes.First()); } if (egg.IsDone()) { break; } } /* * while (!egg.IsDone()) * { * if (bunny.Energy == 0) * { * break; * } * * if (bunny.Dyes.All(x => x.IsFinished())) * { * break; * } * * egg.GetColored(); * bunny.Work(); ; * } * */ }
public string AddDyeToBunny(string bunnyName, int power) { IBunny currentBunny = bunnies.FindByName(bunnyName); if (currentBunny == null) { throw new InvalidOperationException(ExceptionMessages.InexistentBunny); } IDye currentDye = new Dye(power); currentBunny.AddDye(currentDye); return($"{String.Format(OutputMessages.DyeAdded, power, bunnyName)}"); }
public string AddDyeToBunny(string bunnyName, int power) { IBunny bunny = bunnies.FindByName(bunnyName); if (bunny == null) { throw new InvalidOperationException("The bunny you want to add a dye to doesn't exist!"); } bunny.AddDye(new Dye(power)); return($"Successfully added dye with power {power} to bunny {bunnyName}!"); }
public string AddDyeToBunny(string bunnyName, int power) //ok? { IBunny bunny = bunnies.FindByName(bunnyName); if (bunny == null) { throw new InvalidOperationException(string.Format(ExceptionMessages.InexistentBunny)); } Dye dye = new Dye(power); bunny.AddDye(dye); return($"Successfully added dye with power {power} to bunny {bunnyName}!"); }
public string AddDyeToBunny(string bunnyName, int power) { Dye dye = new Dye(power); IBunny bunny = bunnies.FindByName(bunnyName); if (bunny == null) { throw new InvalidOperationException(ExceptionMessages.InexistentBunny); } bunny.AddDye(dye); return(string.Format(OutputMessages.DyeAdded, power, bunnyName)); }