Exemplo n.º 1
0
func (ss *StoreService) PeriodicWake() {
	now := time.Now().Unix()
	if ss.lastWake == 0 {
		ss.lastWake = now
	}
	period := int64(10)
	if now-ss.lastWake < period {
		return
	}
	ss.lastWake = now
	d := util.GetOrCreateDB(containersDB())
	keys := d.Keys()
	for {
		key := <-keys
		if len(key) == 0 {
			break
		}
		bytesUsed := 0
		id := msg.OcID(key)
		container := NewContainerFromDisk(id)
		seenBlocks := make(map[string]bool)
		for _, blobID := range container.BlobIDs {
			// TODO(ortutay): don't read blocks from disk just to find sizes
			blob, err := NewBlobFromDisk(blobID)
			if err != nil {
				continue
			}
			for _, block := range blob.Blocks {
				if _, ok := seenBlocks[block.ID.String()]; ok {
					continue
				}
				seenBlocks[block.ID.String()] = true
				bytesUsed += len(block.Data)
			}
		}
		costPv := costForBytesSeconds(bytesUsed, int(period))
		fmt.Printf("bytes %v used by %v..., cost += %f %v\n",
			bytesUsed, id.String()[:8], util.S2B(costPv.Amount), costPv.Currency)
		rec := rep.Record{
			Role:         rep.SERVER,
			Service:      SERVICE_NAME,
			Method:       PUT_METHOD,
			Timestamp:    int(now),
			ID:           id,
			Status:       rep.SUCCESS_UNPAID,
			PaymentValue: costPv,
			Perf:         nil,
		}
		rep.Put(&rec)
	}
}
Exemplo n.º 2
0
func (cs CalcService) calculate(req *msg.OcReq) (*msg.OcResp, error) {
	// TODO(ortutay): pull out payment verifcation logic
	work, err := Measure(req)
	if err != nil {
		log.Printf("server error: %v", err.Error())
		return msg.NewRespError(msg.SERVER_ERROR), nil
	}
	pv, err := cs.paymentForWork(work, CALCULATE_METHOD)
	if err != nil {
		log.Printf("server error: %v", err.Error())
		return msg.NewRespError(msg.SERVER_ERROR), nil
	}
	var submitTxn string
	if pv.Amount != 0 {
		fmt.Printf("want payment: %v, got payment: %v\n", pv, req.PaymentValue)
		if req.PaymentType == msg.NONE || req.PaymentValue == nil {
			return msg.NewRespError(msg.PAYMENT_REQUIRED), nil
		}
		if req.PaymentValue.Currency != pv.Currency {
			return msg.NewRespError(msg.CURRENCY_UNSUPPORTED), nil
		}
		if req.PaymentValue.Amount < pv.Amount {
			return msg.NewRespError(msg.TOO_LOW), nil
		}

		var repStatus rep.Status
		switch req.PaymentType {
		case msg.DEFER:
			// TODO(ortutay): check if we accept deferred payment for the request
			// TODO(ortutay): marking as success is pre-emptive; need to handle
			// failure case
			repStatus = rep.SUCCESS_UNPAID
		case msg.ATTACHED:
			if !btc.TxnIsValid(req.PaymentTxn, req.PaymentValue) {
				return msg.NewRespError(msg.INVALID_TXN), nil
			}
			submitTxn = req.PaymentTxn
			// TODO(ortutay): same note as above about pre-emptive success mark
			repStatus = rep.SUCCESS_PAID
		}
		rec := rep.Record{
			Role:         rep.SERVER,
			Service:      SERVICE_NAME,
			Method:       CALCULATE_METHOD,
			Timestamp:    int(time.Now().Unix()),
			ID:           req.ID,
			Status:       repStatus,
			PaymentType:  msg.DEFER,
			PaymentValue: pv,
			Perf:         nil,
		}
		fmt.Printf("rep rec: %v\n", rec)
		id, err := rep.Put(&rec)
		if err != nil {
			return nil, fmt.Errorf("local database error: %v", err)
		}
		fmt.Printf("stored rep rec, %v %v\n", id, err)
	}

	var results []string
	for _, q := range req.Args {
		tokens := strings.Split(q, " ")
		var stack []float64
		for _, token := range tokens {
			switch token {
			case "+":
				r := stack[len(stack)-1] + stack[len(stack)-2]
				stack = stack[0 : len(stack)-2]
				stack = append(stack, r)
			case "-":
				r := stack[len(stack)-2] - stack[len(stack)-1]
				stack = stack[0 : len(stack)-2]
				stack = append(stack, r)
			case "/":
				r := stack[len(stack)-2] / stack[len(stack)-1]
				stack = stack[0 : len(stack)-2]
				stack = append(stack, r)
			case "*":
				r := stack[len(stack)-1] * stack[len(stack)-2]
				stack = stack[0 : len(stack)-2]
				stack = append(stack, r)
			default:
				f, err := strconv.ParseFloat(token, 54)
				stack = append(stack, f)
				if err != nil {
					return nil, errors.New("didn't understand \"" + token + "\"")
				}
			}
		}
		if len(stack) != 1 {
			return nil, errors.New("invalid expression")
		}
		results = append(results, fmt.Sprintf("%v", stack[0]))
	}
	resp := msg.NewRespOk([]byte(strings.Join(results, " ")))
	if submitTxn != "" {
		_ = btc.SubmitTxn(submitTxn)
	}
	return resp, nil
}