コード例 #1
0
ファイル: rep_test.go プロジェクト: therob3000/decloud
func TestPaymentValueServedToOcID(t *testing.T) {
	defer os.RemoveAll(testutil.InitDir(t))
	id := msg.OcID("id-123")
	otherID := msg.OcID("id-other")
	_, err := Put(&Record{
		Role:         SERVER,
		ID:           id,
		Status:       SUCCESS_PAID,
		PaymentValue: &msg.PaymentValue{Amount: 1000, Currency: msg.BTC},
	})
	if err != nil {
		t.Fatal(err)
	}
	_, err = Put(&Record{
		Role:         SERVER,
		ID:           id,
		Status:       SUCCESS_UNPAID,
		PaymentValue: &msg.PaymentValue{Amount: 2000, Currency: msg.BTC},
	})
	if err != nil {
		t.Fatal(err)
	}
	_, err = Put(&Record{
		Role:         SERVER,
		ID:           otherID,
		Status:       SUCCESS_PAID,
		PaymentValue: &msg.PaymentValue{Amount: 3000, Currency: msg.BTC},
	})
	if err != nil {
		t.Fatal(err)
	}
	_, err = Put(&Record{
		Role:         SERVER,
		ID:           id,
		Status:       PENDING,
		PaymentValue: &msg.PaymentValue{Amount: 4000, Currency: msg.BTC},
	})
	if err != nil {
		t.Fatal(err)
	}
	_, err = Put(&Record{
		Role:         SERVER,
		ID:           id,
		Status:       FAILURE,
		PaymentValue: &msg.PaymentValue{Amount: 5000, Currency: msg.BTC},
	})
	if err != nil {
		t.Fatal(err)
	}

	pv, err := PaymentValueServedToOcID(id)
	if err != nil {
		t.Fatal(err)
	}
	if 3000 != pv.Amount {
		t.Fatalf("%v != %v", 3000, pv.Amount)
	}
}
コード例 #2
0
ファイル: peer_test.go プロジェクト: therob3000/decloud
func TestAmountPaid(t *testing.T) {
	defer os.RemoveAll(testutil.InitDir(t))
	btcConf, err := util.LoadBitcoindConf("")
	if err != nil {
		t.Fatal(err)
	}
	peer := Peer{ID: msg.OcID("123id")}
	otherPeer := Peer{ID: msg.OcID("456otherid")}

	addr, err := peer.PaymentAddr(1, btcConf)
	if err != nil {
		t.Fatal(err)
	}
	otherAddr, err := otherPeer.PaymentAddr(1, btcConf)
	if err != nil {
		t.Fatal(err)
	}
	fmt.Printf("addr %v other addr %v\n", addr, otherAddr)

	// Send some BTC to ourselves.
	amt := int64(1e6)
	cmd, err := btcjson.NewSendToAddressCmd("", addr, amt)
	if err != nil {
		log.Fatal(err)
	}
	sendBtcResp, err := util.SendBtcRpc(cmd, btcConf)
	_, ok := sendBtcResp.Result.(string)
	if !ok {
		log.Fatal(sendBtcResp)
	}

	// Send some BTC to another address.
	cmd, err = btcjson.NewSendToAddressCmd("", otherAddr, 1e6)
	if err != nil {
		log.Fatal(err)
	}
	sendBtcResp, err = util.SendBtcRpc(cmd, btcConf)
	_, ok = sendBtcResp.Result.(string)
	if !ok {
		log.Fatal(sendBtcResp)
	}

	// Verify balance
	pv, err := peer.AmountPaid(0, btcConf)
	if err != nil {
		log.Fatal(err)
	}
	if pv.Amount != amt {
		t.Fatalf("%v != %v", paid, amt)
	}
}
コード例 #3
0
ファイル: rep.go プロジェクト: therob3000/decloud
func Reduce(sel *Record, reduceFn func(rec *Record)) error {
	db, err := openOrCreate()
	if err != nil {
		return err
	}
	defer db.Close()

	query := selectLikeRecord(sel)
	rows, err := db.Query(query)
	if err != nil {
		return fmt.Errorf("error while querying %v: %v", query, err.Error())
	}
	for rows.Next() {
		var role, service, method, ocID, status, pvType, pvCurr, perfHex []byte
		var pvAmt int64
		var timestamp int
		err := rows.Scan(
			&role, &service, &method, &timestamp, &ocID, &status, &pvType, &pvAmt,
			&pvCurr, &perfHex)
		var rec Record

		if len(role) != 0 {
			rec.Role = Role(role)
		}
		if len(service) != 0 {
			rec.Service = string(service)
		}
		if len(method) != 0 {
			rec.Method = string(method)
		}
		rec.Timestamp = timestamp
		if len(ocID) != 0 {
			rec.ID = msg.OcID(ocID)
		}
		if len(status) != 0 {
			rec.Status = Status(status)
		}
		if len(pvType) != 0 {
			rec.PaymentType = msg.PaymentType(pvType)
		}
		if len(pvCurr) != 0 {
			pv := msg.PaymentValue{
				Amount:   pvAmt,
				Currency: msg.Currency(pvCurr),
			}
			rec.PaymentValue = &pv
		}
		if len(perfHex) != 0 {
			panic("TODO: implement perf decoding")
		}
		if err != nil {
			return fmt.Errorf("error scanning with %v: %v", query, err.Error())
		}
		reduceFn(&rec)
	}
	return nil
}
コード例 #4
0
ファイル: peer.go プロジェクト: therob3000/decloud
func ocIDForCoin(coin string) (*msg.OcID, error) {
	fmt.Printf("get oc ID for coin: %v\n", coin)
	d := util.GetOrCreateDB(peerDBPath())
	v, _ := d.Read(coin)
	if v == nil || len(v) == 0 {
		return nil, nil
	}
	id := msg.OcID(v)
	return &id, nil
}
コード例 #5
0
ファイル: store.go プロジェクト: therob3000/decloud
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)
	}
}
コード例 #6
0
ファイル: rep_test.go プロジェクト: therob3000/decloud
func TestSuccessRate(t *testing.T) {
	defer os.RemoveAll(testutil.InitDir(t))
	id := msg.OcID("id-123")
	otherID := msg.OcID("id-other")
	_, err := Put(&Record{Role: SERVER, ID: id, Status: SUCCESS_PAID})
	if err != nil {
		t.Fatal(err)
	}
	_, err = Put(&Record{Role: SERVER, ID: id, Status: PENDING})
	if err != nil {
		t.Fatal(err)
	}
	_, err = Put(&Record{Role: SERVER, ID: id, Status: FAILURE})
	if err != nil {
		t.Fatal(err)
	}
	_, err = Put(&Record{Role: SERVER, ID: otherID, Status: FAILURE})
	if err != nil {
		t.Fatal(err)
	}

	rate, err := SuccessRate(&Record{Role: SERVER, ID: id})
	if err != nil {
		t.Fatal(err)
	}
	if .5 != rate {
		t.Fatal("Expected %v, got %v", .5, rate)
	}

	rate, err = SuccessRate(&Record{Role: CLIENT, ID: id})
	if err != nil {
		t.Fatal(err)
	}
	if -1 != rate {
		t.Fatal("Expected %v, got %v", -1, rate)
	}
}
コード例 #7
0
ファイル: peer_test.go プロジェクト: therob3000/decloud
func TestGetAndSet(t *testing.T) {
	defer os.RemoveAll(testutil.InitDir(t))
	id := msg.OcID("1abc")
	err := setOcIDForCoin("1abc", &id)
	if err != nil {
		t.Fatalf("err: %v", err.Error())
	}
	id2, err := ocIDForCoin("1abc")
	if err != nil {
		t.Fatalf("err: %v", err)
	}
	fmt.Printf("id2: %v\n", id2)
	if id != *id2 {
		t.Fatalf("%v %v", id, id2)
	}
}
コード例 #8
0
ファイル: peer_test.go プロジェクト: therob3000/decloud
func TestGetAddr(t *testing.T) {
	defer os.RemoveAll(testutil.InitDir(t))
	btcConf, err := util.LoadBitcoindConf("")
	if err != nil {
		t.Errorf("%v", err)
	}
	p := Peer{ID: msg.OcID("123id")}
	addr1, err := p.PaymentAddr(1, btcConf)
	if err != nil {
		log.Fatal(err)
	}
	addr2, err := p.PaymentAddr(1, btcConf)
	if err != nil {
		log.Fatal(err)
	}
	if addr1 != addr2 {
		t.Fatalf("%v != %v\n", addr1, addr2)
	}
}
コード例 #9
0
ファイル: rep_test.go プロジェクト: therob3000/decloud
func TestRepPut(t *testing.T) {
	defer os.RemoveAll(testutil.InitDir(t))
	rec := Record{
		Role:         SERVER,
		Service:      "store",
		Method:       "put",
		Timestamp:    1234,
		ID:           msg.OcID("id-123"),
		Status:       SUCCESS_PAID,
		PaymentType:  msg.TXID,
		PaymentValue: &msg.PaymentValue{Amount: 1000, Currency: msg.BTC},
		Perf:         nil,
	}

	_, err := Put(&rec)
	if err != nil {
		t.Fatal(err)
	}
}
コード例 #10
0
ファイル: cred.go プロジェクト: therob3000/decloud
func (o *OcCred) ID() msg.OcID {
	// TODO(ortutay): compress pub key
	return msg.OcID(fmt.Sprintf("%c%x,%x",
		OC_ID_PREFIX, o.Priv.PublicKey.X, o.Priv.PublicKey.Y))
}