src/main/java/at/ac/tuwien/sbc/valesriegler/xvsm/WaiterXVSM.java

   1 package at.ac.tuwien.sbc.valesriegler.xvsm;
   2
   3 import at.ac.tuwien.sbc.valesriegler.common.OrderId;
   4 import at.ac.tuwien.sbc.valesriegler.common.Util;
   5 import at.ac.tuwien.sbc.valesriegler.types.*;
   6 import at.ac.tuwien.sbc.valesriegler.xvsm.spacehelpers.SpaceAction;
   7 import at.ac.tuwien.sbc.valesriegler.xvsm.spacehelpers.SpaceListener;
   8 import org.mozartspaces.core.MzsConstants.RequestTimeout;
   9 import org.mozartspaces.core.MzsCoreException;
  10 import org.mozartspaces.core.TransactionReference;
  11 import org.slf4j.Logger;
  12 import org.slf4j.LoggerFactory;
  13
  14 import java.io.Serializable;
  15 import java.util.Arrays;
  16 import java.util.List;
  17
  18 public class WaiterXVSM extends AbstractXVSMConnector {
  19     private static final Logger log = LoggerFactory.getLogger(WaiterXVSM.class);
  20     private final int waiterId;
  21
  22     public WaiterXVSM(int waiterId, int port) {
  23         super(port);
  24
  25         this.waiterId = waiterId;
  26
  27         freeTablesContainer = useContainer(Util.FREE_TABLES);
  28         assignTableContainer = useContainer(Util.ASSIGN_TABLE);
  29         takeOrderContainer = useContainer(Util.TAKE_ORDER);
  30         orderTakenContainer = useContainer(Util.ORDER_TAKEN);
  31         deliveryOrderTakenContainer = useContainer(Util.DELIVERY_ORDER_TAKEN);
  32         preparePizzasContainer = useContainer(Util.PREPARE_PIZZAS);
  33         prepareDeliveryPizzasContainer = useContainer(Util.PREPARE_DELIVERY_PIZZAS);
  34         orderDeliveredContainer = useContainer(Util.ORDER_COMPLETE);
  35         preparedPizzasContainer = useContainer(Util.DELIVER_PIZZAS);
  36         paymentRequestContainer = useContainer(Util.PAYMENT_REQUEST);
  37         paymentDoneContainer = useContainer(Util.PAYMENT_DONE);
  38         tableAssignedContainer = useContainer(Util.TABLE_ASSIGNED);
  39         pizzeriaInfoContainer = useContainer(Util.PIZZERIA_INFO);
  40         phoneCallsContainer = useContainer(Util.PHONE_CALLS);
  41         preparedDeliveryPizzasContainer = useContainer(Util.DELIVER_DELIVERY_PIZZAS);
  42         deliverDeliveryOrderContainer = useContainer(Util.DELIVER_DELIVERY_ORDER);
  43         pizzeriaGroupContainer = useContainer(Util.PIZZERIA_GROUP);
  44         pizzeriaTableContainer = useContainer(Util.PIZZERIA_TABLE);
  45         pizzeriaDeliveryContainer = useContainer(Util.PIZZERIA_DELIVERY);
  46     }
  47
  48     public void listenForPhoneOrders() {
  49         getDefaultBuilder().setCref(phoneCallsContainer).setLookaround(true).setSpaceAction(new SpaceAction() {
  50             @Override
  51             public void onEntriesWritten(List<? extends Serializable> entries) throws Exception {
  52                 final List<DeliveryGroupData> phoneOrders = castEntries(entries);
  53
  54 //                if(inNotification.get()) Collections.shuffle(phoneOrders);
  55
  56                 for (DeliveryGroupData phoneOrder : phoneOrders) {
  57                     final int id = phoneOrder.getId();
  58                     final DeliveryGroupData template = new DeliveryGroupData(id);
  59                     final String errorMsg = String.format("There was phone call with id %d. Another waiter already responded!", id);
  60
  61                     final TransactionReference tx = getDefaultTransaction();
  62                     try {
  63                         // Get the the delete lock so that only one waiter can answer this particular phone call
  64                         takeMatchingEntity(template, phoneCallsContainer, tx, RequestTimeout.DEFAULT, errorMsg);
  65
  66                         final DeliveryGroupData group = takeMatchingEntity(template, pizzeriaDeliveryContainer, tx, RequestTimeout.INFINITE, errorMsg);
  67                         group.setWaiterIdOfOrder(WaiterXVSM.this.waiterId);
  68                         final Order order = group.getOrder();
  69                         group.setDeliveryStatus(DeliveryStatus.ORDERED);
  70
  71                         updatePizzeriaOrderNumber(order, tx);
  72
  73                         // send the order as a whole to the space
  74                         final List<DeliveryGroupData> groupsWhoHaveOrdered = Arrays.asList(group);
  75                         sendItemsToContainer(groupsWhoHaveOrdered,
  76                                 deliveryOrderTakenContainer, RequestTimeout.ZERO, tx);
  77                         sendItemsToContainer(groupsWhoHaveOrdered,
  78                                 pizzeriaDeliveryContainer, RequestTimeout.ZERO, tx);
  79                         sendItemsToContainer(order.getOrderedPizzas(),
  80                                 prepareDeliveryPizzasContainer, RequestTimeout.ZERO, tx);
  81                         capi.commitTransaction(tx);
  82
  83                         log.info("Waiter has taken a phone delivery call!");
  84                     } catch (Exception e) {
  85                     }
  86                 }
  87
  88             }
  89         }).createSpaceListenerImpl();
  90     }
  91
  92     public void listenForFreeTable() {
  93         SpaceListener listener = getDefaultBuilder().setCref(freeTablesContainer).setSpaceAction(new SpaceAction() {
  94
  95             @Override
  96             public void onEntriesWritten(List<? extends Serializable> entries) throws Exception {
  97
  98                 List<Table> tables = castEntries(entries);
  99
 100                 for (Table table : tables) {
 101
 102                     TransactionReference tx = getDefaultTransaction();
 103
 104                     // Acquire a lock for the free table in the
 105                     // FreeTableContainer
 106                     int id = table.getId();
 107
 108                     Table tableTemplate = new Table(id);
 109                     try {
 110                         Table lockedFreeTable = takeMatchingEntity(tableTemplate,
 111                                 freeTablesContainer, tx, RequestTimeout.DEFAULT,
 112                                 String.format("There was no free table found with id %d", id));
 113                         takeMatchingEntityIfItExists(tableTemplate, pizzeriaTableContainer, tx, RequestTimeout.DEFAULT);
 114
 115                         GroupData groupTemplate = new GroupData();
 116                         GroupData lockedGroup = takeMatchingEntity(groupTemplate,
 117                                 assignTableContainer, tx, RequestTimeout.DEFAULT,
 118                                 "There is no group waiting for a table at the moment");
 119                         takeMatchingEntityIfItExists(lockedGroup, pizzeriaGroupContainer, tx, RequestTimeout.DEFAULT);
 120
 121                         assignGroupToTable(lockedGroup, lockedFreeTable, tx);
 122                     } catch (Exception e) {
 123 //                                              log.info(e.getMessage());
 124                     }
 125                 }
 126             }
 127         }).createSpaceListenerImpl();
 128     }
 129
 130
 131     public void listenForNewGuests() {
 132         SpaceListener listener = getDefaultBuilder().setLookaround(true).setCref(assignTableContainer).setSpaceAction(new SpaceAction() {
 133
 134             @Override
 135             public void onEntriesWritten(List<? extends Serializable> entries)
 136                     throws Exception {
 137                 log.info("New guest groups have arrived");
 138
 139                 List<GroupData> groups = castEntries(entries);
 140
 141                 for (GroupData group : groups) {
 142
 143                     TransactionReference tx = getDefaultTransaction();
 144
 145                     // Acquire a lock for the group in the
 146                     // AssignTableContainer
 147                     String groupNotFound = String.format("Group with id %d was already assigned a table by another waiter!", group.getId());
 148
 149                     try {
 150                         final GroupData templateGroup = new GroupData(group.getId());
 151                         GroupData lockedGroup = takeMatchingEntity(
 152                                 templateGroup,
 153                                 assignTableContainer, tx,
 154                                 RequestTimeout.DEFAULT, groupNotFound);
 155                         takeMatchingEntityIfItExists(templateGroup, pizzeriaGroupContainer, tx, RequestTimeout.DEFAULT);
 156                         // Acquire a lock for one free table in the
 157                         // TablesContainer
 158                         String noFreeTable = String.format("No free table for group with id %d could be found", group.getId());
 159                         final Table freeTable = new Table(null);
 160                         freeTable.setFree(true);
 161                         Table lockedFreeTable = takeMatchingEntity(freeTable, freeTablesContainer, tx, RequestTimeout.DEFAULT,
 162                                 noFreeTable);
 163                         takeMatchingEntityIfItExists(lockedFreeTable, pizzeriaTableContainer, tx, RequestTimeout.DEFAULT);
 164
 165                         assignGroupToTable(lockedGroup, lockedFreeTable, tx);
 166                     } catch (Exception e) {
 167 //                                              log.info(e.getMessage());
 168                     }
 169                 }
 170             }
 171         }).createSpaceListenerImpl();
 172     }
 173
 174     public void listenForPaymentRequest() {
 175         SpaceListener paymentListener = getDefaultBuilder().setCref(paymentRequestContainer).setSpaceAction(new SpaceAction() {
 176
 177             @Override
 178             public void onEntriesWritten(List<? extends Serializable> entries)
 179                     throws Exception {
 180
 181                 List<GroupData> groups = castEntries(entries);
 182
 183                 for (GroupData groupData : groups) {
 184                     TransactionReference tx = getDefaultTransaction();
 185                     GroupData entity = new GroupData(groupData.getId());
 186                     entity.setState(GroupState.PAY);
 187
 188                     // Acquire the lock so that another waiter can't do the same
 189                     // thing!
 190                     String paymentRequestTakenByOtherWaiter = String.format(
 191                             "The payment request for group %d was already taken by an other waiter!",
 192                             groupData.getId());
 193                     try {
 194                         takeMatchingEntity(entity, paymentRequestContainer, tx, RequestTimeout.DEFAULT, paymentRequestTakenByOtherWaiter);
 195                         GroupData group = takeMatchingEntity(entity, pizzeriaGroupContainer, tx, RequestTimeout.DEFAULT, "Cannot get paying group!");
 196                         group.setPayingWaiter(waiterId);
 197                         group.setState(GroupState.GONE);
 198
 199                         final Table tableTemplate = new Table(null);
 200                         tableTemplate.setGroupId(group.getId());
 201                         final Table table = takeMatchingEntity(tableTemplate, pizzeriaTableContainer, tx, RequestTimeout.DEFAULT, "Table was not found!");
 202                         table.setGroupId(-1);
 203                         final List<Table> tables = Arrays.asList(table);
 204                         sendItemsToContainer(tables, pizzeriaTableContainer, RequestTimeout.DEFAULT, tx);
 205                         sendItemsToContainer(tables, freeTablesContainer, RequestTimeout.DEFAULT, tx);
 206
 207                         final List<GroupData> groupsPayed = Arrays.asList(group);
 208                         sendItemsToContainer(groupsPayed, paymentDoneContainer, RequestTimeout.DEFAULT, tx);
 209                         sendItemsToContainer(groupsPayed, pizzeriaGroupContainer, RequestTimeout.DEFAULT, tx);
 210
 211                         capi.commitTransaction(tx);
 212                     } catch (Exception e) {
 213                                                 log.info(e.getMessage());
 214                     }
 215                 }
 216             }
 217         }).createSpaceListenerImpl();
 218     }
 219
 220     public void listenForOrderRequests() {
 221         getDefaultBuilder().setCref(takeOrderContainer).setSpaceAction(new SpaceAction() {
 222
 223             @Override
 224             public void onEntriesWritten(List<? extends Serializable> entries)
 225                     throws Exception {
 226
 227                 List<GroupData> groups = castEntries(entries);
 228
 229                 for (GroupData groupData : groups) {
 230
 231                     TransactionReference tx = getDefaultTransaction();
 232                     GroupData entity = new GroupData(groupData.getId());
 233                     entity.setState(GroupState.SITTING);
 234
 235                     try {
 236                         // Acquire the lock so that another waiter can't do the same thing!
 237                         String orderTakenByOtherWaiter = String.format(
 238                                 "The order for group %d was already taken by an other waiter!",
 239                                 groupData.getId());
 240                         takeMatchingEntity(entity, takeOrderContainer, tx, RequestTimeout.DEFAULT, orderTakenByOtherWaiter);
 241                         GroupData group = takeMatchingEntityIfItExists(entity, pizzeriaGroupContainer, tx, RequestTimeout.INFINITE);
 242
 243                         group.setOrderWaiter(waiterId);
 244                         group.setState(GroupState.ORDERED);
 245                         Order order = group.getOrder();
 246                         order.setStatus(OrderStatus.ORDERED);
 247
 248                         /*  get the id of the last order of the pizzeria and set the order accordingly and
 249                             update the space */
 250                         updatePizzeriaOrderNumber(order, tx);
 251
 252                         // send the order as a whole to the space
 253                         final List<GroupData> groupsWhoHaveOrdered = Arrays.asList(group);
 254                         sendItemsToContainer(groupsWhoHaveOrdered,
 255                                 orderTakenContainer, RequestTimeout.ZERO, tx);
 256                         sendItemsToContainer(groupsWhoHaveOrdered,
 257                                 pizzeriaGroupContainer, RequestTimeout.ZERO, tx);
 258                         sendItemsToContainer(order.getOrderedPizzas(),
 259                                 preparePizzasContainer, RequestTimeout.ZERO, tx);
 260                         capi.commitTransaction(tx);
 261
 262                         log.info("Waiter has taken order from group {}",
 263                                 group.getId());
 264                     } catch (Exception e) {
 265 //                                              log.info(e.getMessage());
 266                     }
 267                 }
 268             }
 269         }).createSpaceListenerImpl();
 270     }
 271
 272     public void listenForPreparedPizzas() {
 273         /**
 274          * A waiter gets informed when a new pizza is complete. He takes the
 275          * orderId of the pizza and looks up the corresponding order from which
 276          * he gets the number of necessary pizzas of the order. He then tries to
 277          * fetch all pizzas with the corresponding orderId and compares the
 278          * number of those pizzas with the number of necessary pizzas. If all
 279          * pizzas of an order are complete he then delivers them!
 280          */
 281         getDefaultBuilder().setLookaround(true).setCref(preparedPizzasContainer).setSpaceAction(new SpaceAction() {
 282
 283             @Override
 284             public void onEntriesWritten(List<? extends Serializable> entries)
 285                     throws Exception {
 286                 log.info("NEW PIZZAS ARRived");
 287
 288                 List<Pizza> pizzas = castEntries(entries);
 289
 290                 for (Pizza pizza : pizzas) {
 291                     int orderId = pizza.getOrderId();
 292                     Order order = new Order();
 293                     order.setId(orderId);
 294
 295                     TransactionReference tx = getDefaultTransaction();
 296
 297                     try {
 298                         GroupData entity = new GroupData();
 299                         entity.setState(GroupState.ORDERED);
 300                         entity.setOrder(order);
 301
 302                         takeMatchingEntity(entity,
 303                                 orderTakenContainer, tx, RequestTimeout.DEFAULT,
 304                                 "Another waiter just checks if the order is complete");
 305                         GroupData groupData = takeMatchingEntityIfItExists(entity,
 306                                 pizzeriaGroupContainer, tx, RequestTimeout.INFINITE);
 307                         int numberOfPizzas = groupData.getOrder().getNumberOfPizzas();
 308
 309                         Pizza pizzaTemplate = new Pizza();
 310                         pizzaTemplate.setOrderId(orderId);
 311
 312                         List<Pizza> pizzasOfOrder = takeMatchingEntities(
 313                                 pizzaTemplate, preparedPizzasContainer, tx,
 314                                 RequestTimeout.DEFAULT,
 315                                 "Cannot take the pizzas from the preparedPizzasContainer");
 316
 317                         final List<GroupData> groupsWithCompleteOrder = Arrays.asList(groupData);
 318                         if (pizzasOfOrder.size() == numberOfPizzas) {
 319                             groupData.setServingWaiter(waiterId);
 320                             groupData.setState(GroupState.EATING);
 321                             groupData.getOrder().setStatus(OrderStatus.DELIVERED);
 322                             sendItemsToContainer(groupsWithCompleteOrder,
 323                                     orderDeliveredContainer, RequestTimeout.DEFAULT,
 324                                     tx);
 325                             sendItemsToContainer(groupsWithCompleteOrder,
 326                                     pizzeriaGroupContainer, RequestTimeout.DEFAULT,
 327                                     tx);
 328
 329                             capi.commitTransaction(tx);
 330                         } else {
 331                             log.info("Not yet all pizzas prepared! Order with id "
 332                                     + orderId + " has " + numberOfPizzas
 333                                     + " pizzas, but only " + pizzasOfOrder.size()
 334                                     + " pizzas are ready by now!");
 335                             capi.rollbackTransaction(tx);
 336                         }
 337                     } catch (NullPointerException e) {
 338
 339                     } catch (Exception e) {
 340                         capi.rollbackTransaction(tx);
 341                     }
 342                 }
 343             }
 344         }).createSpaceListenerImpl();
 345     }
 346
 347     private void assignGroupToTable(GroupData lockedGroup,
 348                                     Table lockedFreeTable, TransactionReference tx)
 349             throws MzsCoreException {
 350         // The new group sits down at the table
 351         lockedFreeTable.setGroupId(lockedGroup.getId());
 352
 353         // The new group now wants to order
 354         lockedGroup.setState(GroupState.SITTING);
 355         lockedGroup.setTable(lockedFreeTable);
 356         lockedGroup.setTableWaiter(waiterId);
 357
 358         final List<Table> freeTables = Arrays.asList(lockedFreeTable);
 359         sendItemsToContainer(freeTables,
 360                 pizzeriaTableContainer, RequestTimeout.ZERO, tx);
 361         sendItemsToContainer(freeTables,
 362                 tableAssignedContainer, RequestTimeout.ZERO, tx);
 363         sendItemsToContainer(Arrays.asList(lockedGroup), takeOrderContainer,
 364                 RequestTimeout.ZERO, tx);
 365         sendItemsToContainer(Arrays.asList(lockedGroup), pizzeriaGroupContainer,
 366                 RequestTimeout.ZERO, tx);
 367
 368         try {
 369             capi.commitTransaction(tx);
 370             log.info("Assigned table to group with groupId {}",
 371                     lockedGroup.getId());
 372         } catch (Exception e) {
 373             log.info("Assigning a table to group with groupId {} failed",
 374                     lockedGroup.getId());
 375             log.info(e.getMessage());
 376         }
 377     }
 378
 379     private void updatePizzeriaOrderNumber(Order order, TransactionReference tx) throws MzsCoreException {
 380     /*  get the id of the last order of the pizzeria and set the order accordingly and
 381         update the space */
 382         final OrderId orderId = takeMatchingEntity(new OrderId(null), pizzeriaInfoContainer, tx, RequestTimeout.INFINITE, "The Order id object could not be taken from the space!");
 383         final int id = orderId.getId();
 384         final int nextId = id + 1;
 385         order.setId(nextId);
 386         final List<PizzaOrder> orderedPizzas = order.getOrderedPizzas();
 387         for (PizzaOrder orderedPizza : orderedPizzas) {
 388             orderedPizza.setOrderId(nextId);
 389         }
 390         sendItemsToContainer(Arrays.asList(new OrderId(nextId)), pizzeriaInfoContainer, RequestTimeout.DEFAULT, tx);
 391     }
 392 }