func (as *AirlineServer) initTrans(request *Request) {
	args := request.content.value.(*airlineproto.TranArgs)
	tranID := args.TranID
	flightIDs := strings.Split(args.FlightID, ":")
	amount := args.Amount
	pptList := args.PptList
	tm := args.TM
	decision := transaction.COMMIT
	log.Printf("[%s:%s] Receive Init T(%s)", as.airlineID, as.myhostport, tranID)
	logList := bufi.NewBuf()
	for _, flightID := range flightIDs {
		info, exist := as.getFlightInfo(flightID)
		if exist == false || info.Slot < amount {
			decision = transaction.ABORT
			if exist == true {
				// lsplog.Vlogf(5, "[%s:%s] Slot %d >= Amount %d", as.airlineID, as.myhostport, info.Slot, amount)
			}
			break
		} else {
			getLock := as.getFlightLock(flightID)
			if getLock == false {
				// @@ defer or refuse??
				decision = transaction.ABORT
				// lsplog.Vlogf(5, "could not get lock")
				break
			} else {
				log := &transLog{UPDATE, tranID, flightID, info.Slot, info.Slot - amount, pptList, tm}
				logList.Insert(log)
			}
		}
	}

	if decision == transaction.COMMIT {
		// TODO: store log to persistent storage

	} else {
		// TODO: store log to persistent storage
		log.Printf("[%s:%s] Decision for T(%s): %d", as.airlineID, as.myhostport, tranID, decision)
	}
	conn, err := as.lib_conn.GetServerAt(tm)
	if err != nil {
		return
	}

	if request.own == true {
		log.Printf("[%s:%s] Vote %d for T(%s)", as.airlineID, as.myhostport, decision, tranID)
		newArgs := &airlineproto.TranArgs{transaction.TRANS_RESPONSE,
			tranID, args.FlightID, 0, nil, decision, as.myhostport}
		var reply airlineproto.TranReply
		err = conn.Call("TranRPC.TransResponse", newArgs, &reply)
	}

	if decision == transaction.COMMIT {
		as.logBuf[tranID] = logList
		go as.transTimer(tranID)
	}
}
func (la *Libairline) MakeBooking(flightids []string, isRemove bool) error {
	//TODO: Handle remove
	orderQuantity := 1

	if isRemove {
		orderQuantity = -1
	}

	orderGrpMap := make(map[string]*bufi.Buf)

	for _, v := range flightids {
		airlineId := tribproto.GetAirlineFromFlightId(v)
		orderList, exist := orderGrpMap[airlineId]
		if exist == false {
			orderList = bufi.NewBuf()
		}
		orderList.Insert(v)
		orderGrpMap[airlineId] = orderList
	}

	orders := make([]tranlayerproto.Order, len(orderGrpMap))
	i := 0
	for airlineId, orderList := range orderGrpMap {
		flightIds := ""
		for !orderList.Empty() {
			flightId := orderList.Remove().(string)
			if flightIds == "" {
				flightIds = flightId
			} else {
				flightIds = fmt.Sprintf("%s:%s", flightIds, flightId)
			}
		}

		order := tranlayerproto.Order{airlineId, flightIds, orderQuantity}
		orders[i] = order
		i++
	}
	err := la.lib_tranlayer.BookingFlights(orders)
	if lsplog.CheckReport(2, err) {
		return err
	}

	return nil
}
func (tl *TranLayer) initTrans(request *Request) {
	// initialize old transaction
	oldTransaction := &OldTransaction{}

	// create participant list
	orders := request.content.value.([]*tranOrder)
	pptList := make([]string, len(orders))
	for i, order := range orders {
		pptList[i] = order.pptID
	}
	oldTransaction.pptList = pptList
	// send initialize transaction msg to participants
	// create active transaction
	activeTrans := &activeTransMapEle{}
	activeTrans.decision = transaction.NOT_DECIDED
	activeTrans.finished = 0
	pptMap := make(map[string](*rpc.Client))
	commitGrp := make(map[string](int))
	transID := request.content.key
	orderList := bufi.NewBuf()
	log.Printf("[%s] Init T(%s)", tl.myhostport, transID)
	for _, order := range orders {
		orderList.Insert(order)
		//s := []string{order.pptID, order.flightID}
		//transKey := strings.Join(s, "#")
		transKey := order.pptID
		pptMap[transKey] = order.conn
		commitGrp[transKey] = transaction.NOT_DECIDED
	}

	oldTransaction.orderList = orderList
	tl.oldTransactionMap[transID] = oldTransaction

	activeTrans.pptMap = pptMap
	activeTrans.commitGrp = commitGrp
	tl.activeTransMap[transID] = activeTrans

	// TODO: store log to persistent storage

	tl.deferTransMap[transID] = request.replyc
}