Beispiel #1
0
func HandleFactoidBalance(ctx *web.Context, address string) {
	type x struct {
		Response string
		Success  bool
	}

	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)

	if !checkHttpPasswordOkV1(state, ctx) {
		return
	}

	param := AddressRequest{Address: address}
	req := primitives.NewJSON2Request("factoid-balance", 1, param)

	jsonResp, jsonError := HandleV2Request(state, req)
	if jsonError != nil {
		returnV1(ctx, nil, jsonError)
		return
	}

	r := new(x)
	r.Response = fmt.Sprint(jsonResp.Result.(*FactoidBalanceResponse).Balance)
	r.Success = true
	returnMsg(ctx, r, true)

}
Beispiel #2
0
func HandleProperties(ctx *web.Context) {
	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)

	if !checkHttpPasswordOkV1(state, ctx) {
		return
	}

	req := primitives.NewJSON2Request("properties", 1, nil)

	jsonResp, jsonError := HandleV2Request(state, req)
	if jsonError != nil {
		returnV1(ctx, nil, jsonError)
		return
	}
	type x struct {
		Protocol_Version string
		Factomd_Version  string
	}
	d := new(x)
	d.Factomd_Version = jsonResp.Result.(*PropertiesResponse).FactomdVersion
	d.Protocol_Version = "0.0.0.0" // meaningless after v1
	returnMsg(ctx, d, true)
}
Beispiel #3
0
func HandleEntry(ctx *web.Context, hashkey string) {
	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)

	if !checkHttpPasswordOkV1(state, ctx) {
		return
	}

	param := HashRequest{Hash: hashkey}
	req := primitives.NewJSON2Request("entry", 1, param)

	jsonResp, jsonError := HandleV2Request(state, req)
	if jsonError != nil {
		returnV1(ctx, nil, jsonError)
		return
	}
	d := new(EntryStruct)

	d.ChainID = jsonResp.Result.(*EntryResponse).ChainID
	d.Content = jsonResp.Result.(*EntryResponse).Content
	d.ExtIDs = jsonResp.Result.(*EntryResponse).ExtIDs

	returnMsg(ctx, d, true)
}
Beispiel #4
0
func HandleChainHead(ctx *web.Context, chainid string) {
	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)

	if !checkHttpPasswordOkV1(state, ctx) {
		return
	}

	param := ChainIDRequest{ChainID: chainid}
	req := primitives.NewJSON2Request("chain-head", 1, param)

	jsonResp, jsonError := HandleV2Request(state, req)
	if jsonError != nil {
		returnV1(ctx, nil, jsonError)
		return

	}
	// restatement of chead from structs file
	// v1 doesn't like the lcase in v2'
	type CHead struct {
		ChainHead string
	}

	d := new(CHead)
	d.ChainHead = jsonResp.Result.(*ChainHeadResponse).ChainHead
	returnMsg(ctx, d, true)
}
Beispiel #5
0
func HandleDirectoryBlockHeight(ctx *web.Context) {
	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)

	if !checkHttpPasswordOkV1(state, ctx) {
		return
	}

	req := primitives.NewJSON2Request("heights", 1, nil)

	jsonResp, jsonError := HandleV2Request(state, req)
	if jsonError != nil {
		returnV1(ctx, nil, jsonError)
		return
	}

	resp := "{\"Height\":0}"

	// get the HeightsResponse from the return object
	p, err := json.Marshal(jsonResp.Result)
	if err != nil {
		returnV1Msg(ctx, resp, true)
	}
	h := new(HeightsResponse)
	if err := json.Unmarshal(p, h); err != nil {
		returnV1Msg(ctx, resp, true)
	}

	// return just the DirectoryBlockHeight from the HeightsResponse
	resp = fmt.Sprintf("{\"Height\":%d}", h.DirectoryBlockHeight)
	returnV1Msg(ctx, resp, true)
}
Beispiel #6
0
func HandleDirectoryBlockHead(ctx *web.Context) {
	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)

	if !checkHttpPasswordOkV1(state, ctx) {
		return
	}

	req := primitives.NewJSON2Request("directory-block-head", 1, nil)

	jsonResp, jsonError := HandleV2Request(state, req)
	if jsonError != nil {
		returnV1(ctx, nil, jsonError)
		return
	}
	tmp, err := json.Marshal(jsonResp.Result)
	resp := string(tmp)
	if err != nil {
		resp = "{\"KeyMR\",0}"
		returnV1Msg(ctx, resp, true)
	}

	resp = strings.Replace(resp, "keymr", "KeyMR", -1)

	returnV1Msg(ctx, resp, true)
}
Beispiel #7
0
func HandleHeights(ctx *web.Context) {
	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)
	req := primitives.NewJSON2Request("heights", 1, nil)

	jsonResp, jsonError := HandleV2Request(state, req)
	if jsonError != nil {
		returnV1(ctx, nil, jsonError)
		return
	}
	returnMsg(ctx, jsonResp.Result, true)
}
Beispiel #8
0
func HandleGetReceipt(ctx *web.Context, hashkey string) {
	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)

	if !checkHttpPasswordOkV1(state, ctx) {
		return
	}

	param := HashRequest{Hash: hashkey}
	req := primitives.NewJSON2Request("receipt", 1, param)

	jsonResp, jsonError := HandleV2Request(state, req)
	returnV1(ctx, jsonResp, jsonError)
}
Beispiel #9
0
func HandleDirectoryBlock(ctx *web.Context, hashkey string) {
	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)

	if !checkHttpPasswordOkV1(state, ctx) {
		return
	}

	param := KeyMRRequest{KeyMR: hashkey}
	req := primitives.NewJSON2Request("directory-block", 1, param)
	jsonResp, jsonError := HandleV2Request(state, req)
	if jsonError != nil {
		returnV1(ctx, nil, jsonError)
		return
	}

	type DBlock struct {
		Header struct {
			PrevBlockKeyMR string
			SequenceNumber int64
			Timestamp      int64
		}
		EntryBlockList []EBlockAddr
	}
	d := new(DBlock)

	d.Header.PrevBlockKeyMR = jsonResp.Result.(*DirectoryBlockResponse).Header.PrevBlockKeyMR
	d.Header.SequenceNumber = jsonResp.Result.(*DirectoryBlockResponse).Header.SequenceNumber
	d.Header.Timestamp = jsonResp.Result.(*DirectoryBlockResponse).Header.Timestamp
	d.EntryBlockList = jsonResp.Result.(*DirectoryBlockResponse).EntryBlockList

	// conflict if I use local structs.  using a string replace on the structs that would be pointer handled (*DirectoryBlockResponse)
	bResp, err := json.Marshal(d)
	if err != nil {

		returnMsg(ctx, d, true)
	}
	resp := string(bResp)
	resp = strings.Replace(resp, "{\"chainid\"", "{\"ChainID\"", -1)
	resp = strings.Replace(resp, ",\"keymr\":", ",\"KeyMR\":", -1)

	returnV1Msg(ctx, resp, true)
}
Beispiel #10
0
func HandleFactoidSubmit(ctx *web.Context) {
	type x struct {
		Response string
		Success  bool
	}

	type transaction struct{ Transaction string }
	t := new(transaction)

	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)

	if !checkHttpPasswordOkV1(state, ctx) {
		return
	}

	var p []byte
	var err error
	if p, err = ioutil.ReadAll(ctx.Request.Body); err != nil {
		handleV1Error(ctx, NewInvalidParamsError())
		return
	} else {
		if err := json.Unmarshal(p, t); err != nil {
			handleV1Error(ctx, NewInvalidParamsError())
			return
		}
	}

	param := TransactionRequest{Transaction: t.Transaction}
	req := primitives.NewJSON2Request("factoid-submit", 1, param)

	jsonResp, jsonError := HandleV2Request(state, req)
	if jsonError != nil {
		returnV1(ctx, nil, jsonError)
		return
	}
	r := new(x)
	r.Response = jsonResp.Result.(*FactoidSubmitResponse).Message
	r.Success = true
	returnMsg(ctx, r, true)
}
Beispiel #11
0
func TestHandleV2CommitChain(t *testing.T) {
	msg := new(MessageRequest)
	// Can replace with any Chain message
	msg.Message = "00015507b2f70bd0165d9fa19a28cfaafb6bc82f538955a98c7b7e60d79fbf92655c1bff1c76466cb3bc3f3cc68d8b2c111f4f24c88d9c031b4124395c940e5e2c5ea496e8aaa2f5c956749fc3eba4acc60fd485fb100e601070a44fcce54ff358d606698547340b3b6a27bcceb6a42d62a3a8d02a6f0d73653215771de243a63ac048a18b59da2946c901273e616bdbb166c535b26d0d446bc69b22c887c534297c7d01b2ac120237086112b5ef34fc6474e5e941d60aa054b465d4d770d7f850169170ef39150b"
	req := primitives.NewJSON2Request("commit-chain", 0, msg)
	resp, err := v2Request(req)
	if err != nil {
		t.Errorf("%v", err)
	}

	respObj := new(CommitChainResponse)
	if err := MapToObject(resp.Result, respObj); err != nil {
		t.Error(err)
	}

	txID := "76e123d133a841fe3e08c5e3f3d392f8431f2d7668890c03f003f541efa8fc61"
	if respObj.TxID != txID {
		t.Errorf("Error: TxID returned during Commit Chain is incorrect - %v vs %v", respObj.TxID, txID)
	}
}
Beispiel #12
0
func TestHandleV2CommitEntry(t *testing.T) {
	msg := new(EntryRequest)
	// Can replace with any Entry message
	msg.Entry = "00015507C1024BF5C956749FC3EBA4ACC60FD485FB100E601070A44FCCE54FF358D60669854734013B6A27BCCEB6A42D62A3A8D02A6F0D73653215771DE243A63AC048A18B59DA29F4CBD953E6EBE684D693FDCA270CE231783E8ECC62D630F983CD59E559C6253F84D1F54C8E8D8665D493F7B4A4C1864751E3CDEC885A64C2144E0938BF648A00"
	req := primitives.NewJSON2Request("commit-entry", 0, msg)
	resp, err := v2Request(req)
	if err != nil {
		t.Errorf("%v", err)
	}

	respObj := new(CommitEntryResponse)
	if err := MapToObject(resp.Result, respObj); err != nil {
		t.Error(err)
	}

	txID := "8b751bc182766e6187d39b1eca538d9ece0b8ff662e408cd4e45f89359f8c7e7"
	if respObj.TxID != txID {
		t.Errorf("Error: TxID returned during Commit Entry is incorrect - %v vs %v", respObj.TxID, txID)
	}
}
Beispiel #13
0
func HandleEntryBlock(ctx *web.Context, hashkey string) {
	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)

	if !checkHttpPasswordOkV1(state, ctx) {
		return
	}

	param := KeyMRRequest{KeyMR: hashkey}
	req := primitives.NewJSON2Request("entry-block", 1, param)

	jsonResp, jsonError := HandleV2Request(state, req)
	if jsonError != nil {
		returnV1(ctx, nil, jsonError)
		return
	}

	type EBlock struct {
		Header struct {
			BlockSequenceNumber int64
			ChainID             string
			PrevKeyMR           string
			Timestamp           int64
			DBHeight            int64
		}
		EntryList []EntryAddr
	}
	d := new(EBlock)

	d.Header.BlockSequenceNumber = jsonResp.Result.(*EntryBlockResponse).Header.BlockSequenceNumber
	d.Header.ChainID = jsonResp.Result.(*EntryBlockResponse).Header.ChainID
	d.Header.PrevKeyMR = jsonResp.Result.(*EntryBlockResponse).Header.PrevKeyMR
	d.Header.Timestamp = jsonResp.Result.(*EntryBlockResponse).Header.Timestamp
	d.Header.DBHeight = jsonResp.Result.(*EntryBlockResponse).Header.DBHeight
	d.EntryList = jsonResp.Result.(*EntryBlockResponse).EntryList

	returnMsg(ctx, d, true)
}
Beispiel #14
0
func HandleCommitEntry(ctx *web.Context) {
	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)

	if !checkHttpPasswordOkV1(state, ctx) {
		return
	}

	type commitentry struct {
		CommitEntryMsg string
	}

	c := new(commitentry)
	if p, err := ioutil.ReadAll(ctx.Request.Body); err != nil {
		handleV1Error(ctx, NewInvalidParamsError())
		return
	} else {
		if err := json.Unmarshal(p, c); err != nil {
			handleV1Error(ctx, NewInvalidParamsError())
			return
		}
	}

	param := EntryRequest{Entry: c.CommitEntryMsg}
	req := primitives.NewJSON2Request("commit-entry", 1, param)

	_, jsonError := HandleV2Request(state, req)
	if jsonError != nil {
		returnV1(ctx, nil, jsonError)
		return
	}
	//log.Print( jsonResp.Result.(*RevealEntryResponse).Message)

	// this is the blank '200 ok' that is returned for V1
	returnV1Msg(ctx, "", true)

}
Beispiel #15
0
func HandleGetFee(ctx *web.Context) {
	ServersMutex.Lock()
	defer ServersMutex.Unlock()

	state := ctx.Server.Env["state"].(interfaces.IState)

	if !checkHttpPasswordOkV1(state, ctx) {
		return
	}

	req := primitives.NewJSON2Request("entry-credit-rate", 1, nil)

	jsonResp, jsonError := HandleV2Request(state, req)
	if jsonError != nil {
		returnV1(ctx, nil, jsonError)
		return
	}
	type x struct{ Fee int64 }
	d := new(x)

	d.Fee = int64(jsonResp.Result.(*EntryCreditRateResponse).Rate)

	returnMsg(ctx, d, true)
}
Beispiel #16
0
func TestHandleV2GetRaw(t *testing.T) {
	type RawData struct {
		Hash1 string
		Hash2 string
		Raw   string
	}

	toTest := []RawData{}
	var err error

	blockSet := testHelper.CreateTestBlockSet(nil)

	aBlock := blockSet.ABlock
	raw := RawData{}
	raw.Hash1 = aBlock.DatabasePrimaryIndex().String()
	raw.Hash2 = aBlock.DatabaseSecondaryIndex().String()
	hex, err := aBlock.MarshalBinary()
	if err != nil {
		panic(err)
	}
	raw.Raw = primitives.EncodeBinary(hex)
	toTest = append(toTest, raw) //1

	eBlock := blockSet.EBlock
	raw = RawData{}
	raw.Hash1 = eBlock.DatabasePrimaryIndex().String()
	raw.Hash2 = eBlock.DatabaseSecondaryIndex().String()
	hex, err = eBlock.MarshalBinary()
	if err != nil {
		panic(err)
	}
	raw.Raw = primitives.EncodeBinary(hex)
	toTest = append(toTest, raw) //2

	ecBlock := blockSet.ECBlock
	raw = RawData{}
	raw.Hash1 = ecBlock.(interfaces.DatabaseBatchable).DatabasePrimaryIndex().String()
	raw.Hash2 = ecBlock.(interfaces.DatabaseBatchable).DatabaseSecondaryIndex().String()
	hex, err = ecBlock.MarshalBinary()
	if err != nil {
		panic(err)
	}
	raw.Raw = primitives.EncodeBinary(hex)
	toTest = append(toTest, raw) //3

	fBlock := blockSet.FBlock
	raw = RawData{}
	raw.Hash1 = fBlock.(interfaces.DatabaseBatchable).DatabasePrimaryIndex().String()
	raw.Hash2 = fBlock.(interfaces.DatabaseBatchable).DatabaseSecondaryIndex().String()
	hex, err = fBlock.MarshalBinary()
	if err != nil {
		panic(err)
	}
	raw.Raw = primitives.EncodeBinary(hex)
	toTest = append(toTest, raw) //4

	dBlock := blockSet.DBlock
	raw = RawData{}
	raw.Hash1 = dBlock.DatabasePrimaryIndex().String()
	raw.Hash2 = dBlock.DatabaseSecondaryIndex().String()
	hex, err = dBlock.MarshalBinary()
	if err != nil {
		panic(err)
	}
	raw.Raw = primitives.EncodeBinary(hex)
	toTest = append(toTest, raw) //5

	//initializing server
	state := testHelper.CreateAndPopulateTestState()
	Start(state)

	for i, v := range toTest {
		data := new(HashRequest)
		data.Hash = v.Hash1
		req := primitives.NewJSON2Request("raw-data", 1, data)

		resp, err := v2Request(req)
		if err != nil {
			t.Errorf("%v", err)
		}

		if strings.Contains(resp.String(), v.Raw) == false {
			t.Errorf("Looking for %v", v.Hash1)
			t.Errorf("GetRaw %v/%v from Hash1 failed - %v", i, len(toTest), resp.String())
		}

		data.Hash = v.Hash2
		req = primitives.NewJSON2Request("raw-data", 1, data)
		resp, err = v2Request(req)
		if err != nil {
			t.Errorf("%v", err)
		}

		if strings.Contains(resp.String(), v.Raw) == false {
			t.Errorf("Looking for %v", v.Hash1)
			t.Errorf("GetRaw %v/%v from Hash2 failed - %v", i, len(toTest), resp.String())
		}
	}
}