Merge branch 'qt5.4' of github.com-obscure:ethereum/go-ethereum into qt5.4

Conflicts:
	rpc/message.go

.travis.yml

@@ -11,6 +11,7 @@ install:
   # - go get golang.org/x/tools/cmd/vet 
   - if ! go get code.google.com/p/go.tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; fi
   - go get github.com/mattn/goveralls
+  - go get gopkg.in/qml.v1
   - ETH_DEPS=$(go list -f '{{.Imports}} {{.TestImports}} {{.XTestImports}}' github.com/ethereum/go-ethereum/... | sed -e 's/\[//g' | sed -e 's/\]//g' | sed -e 's/C //g'); if [ "$ETH_DEPS" ]; then go get $ETH_DEPS; fi
 before_script:
   - gofmt -l -w .

cmd/utils/cmd.go

@@ -41,7 +41,6 @@ import (
 	rpchttp "github.com/ethereum/go-ethereum/rpc/http"
 	rpcws "github.com/ethereum/go-ethereum/rpc/ws"
 	"github.com/ethereum/go-ethereum/state"
-	// "github.com/ethereum/go-ethereum/websocket"
 	"github.com/ethereum/go-ethereum/xeth"
 )
 
@@ -205,8 +204,6 @@ func StartRpc(ethereum *eth.Ethereum, RpcPort int) {
 func StartWebSockets(eth *eth.Ethereum, wsPort int) {
 	clilogger.Infoln("Starting WebSockets")
 
-	// sock := websocket.NewWebSocketServer(eth)
-	// go sock.Serv()
 	var err error
 	eth.WsServer, err = rpcws.NewWebSocketServer(eth, wsPort)
 	if err != nil {

rpc/message.go

@@ -21,8 +21,6 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
-
-	"github.com/ethereum/go-ethereum/state"
 )
 
 const (
@@ -232,29 +230,6 @@ func (req *RpcRequest) ToFilterChangedArgs() (int, error) {
 	return id, nil
 }
 
-type Log struct {
-	Address string   `json:"address"`
-	Topics  []string `json:"topics"`
-	Data    string   `json:"data"`
-}
-
-func toLogs(logs state.Logs) (ls []Log) {
-	ls = make([]Log, len(logs))
-
-	for i, log := range logs {
-		var l Log
-		l.Topics = make([]string, len(log.Topics()))
-		l.Address = toHex(log.Address())
-		l.Data = toHex(log.Data())
-		for j, topic := range log.Topics() {
-			l.Topics[j] = toHex(topic)
-		}
-		ls[i] = l
-	}
-
-	return
-}
-
 func (req *RpcRequest) ToDbPutArgs() (*DbArgs, error) {
 	if len(req.Params) < 3 {
 		return nil, NewErrorResponse(ErrorArguments)

rpc/packages.go

@@ -40,24 +40,6 @@ import (
 	"github.com/ethereum/go-ethereum/xeth"
 )
 
-func toHex(b []byte) string {
-	return "0x" + ethutil.Bytes2Hex(b)
-}
-func fromHex(s string) []byte {
-	if len(s) > 1 {
-		if s[0:2] == "0x" {
-			s = s[2:]
-		}
-		return ethutil.Hex2Bytes(s)
-	}
-	return nil
-}
-
-type RpcServer interface {
-	Start()
-	Stop()
-}
-
 type EthereumApi struct {
 	xeth          *xeth.XEth
 	filterManager *filter.FilterManager

rpc/json.go → rpc/util.go

@@ -21,6 +21,8 @@ import (
 	"github.com/ethereum/go-ethereum/logger"
 	"io"
 	"net/http"
+	"github.com/ethereum/go-ethereum/ethutil"
+	"github.com/ethereum/go-ethereum/state"
 )
 
 var rpclogger = logger.NewLogger("RPC")
@@ -56,3 +58,44 @@ func (self JsonWrapper) ParseRequestBody(req *http.Request) (RpcRequest, error)
 
 	return reqParsed, nil
 }
+
+func toHex(b []byte) string {
+	return "0x" + ethutil.Bytes2Hex(b)
+}
+func fromHex(s string) []byte {
+	if len(s) > 1 {
+		if s[0:2] == "0x" {
+			s = s[2:]
+		}
+		return ethutil.Hex2Bytes(s)
+	}
+	return nil
+}
+
+type RpcServer interface {
+	Start()
+	Stop()
+}
+
+type Log struct {
+	Address string   `json:"address"`
+	Topics  []string `json:"topics"`
+	Data    string   `json:"data"`
+}
+
+func toLogs(logs state.Logs) (ls []Log) {
+	ls = make([]Log, len(logs))
+
+	for i, log := range logs {
+		var l Log
+		l.Topics = make([]string, len(log.Topics()))
+		l.Address = toHex(log.Address())
+		l.Data = toHex(log.Data())
+		for j, topic := range log.Topics() {
+			l.Topics[j] = toHex(topic)
+		}
+		ls[i] = l
+	}
+
+	return
+}

rpc/ws/server.go

@@ -14,7 +14,7 @@
   You should have received a copy of the GNU General Public License
   along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.
 */
-package ws
+package rpcws
 
 import (
 	"fmt"

websocket/client.go

-package websocket
-
-import (
-	"fmt"
-	"io"
-
-	ws "code.google.com/p/go.net/websocket"
-)
-
-const channelBufSize = 100
-
-var maxId int = 0
-
-type MsgFunc func(c *Client, msg *Message)
-
-// Chat client.
-type Client struct {
-	id     int
-	ws     *ws.Conn
-	server *Server
-	ch     chan *Message
-	doneCh chan bool
-
-	onMessage MsgFunc
-}
-
-// Create new chat client.
-func NewClient(ws *ws.Conn, server *Server) *Client {
-
-	if ws == nil {
-		panic("ws cannot be nil")
-	}
-
-	if server == nil {
-		panic("server cannot be nil")
-	}
-
-	maxId++
-	ch := make(chan *Message, channelBufSize)
-	doneCh := make(chan bool)
-
-	return &Client{maxId, ws, server, ch, doneCh, nil}
-}
-
-func (c *Client) Id() int {
-	return c.id
-}
-
-func (c *Client) Conn() *ws.Conn {
-	return c.ws
-}
-
-func (c *Client) Write(data interface{}, id int) {
-	c.write(&Message{Id: id, Data: data})
-}
-func (c *Client) Event(data interface{}, ev string, id int) {
-	c.write(&Message{Id: id, Data: data, Event: ev})
-}
-
-func (c *Client) write(msg *Message) {
-	select {
-	case c.ch <- msg:
-	default:
-		c.server.Del(c)
-		err := fmt.Errorf("client %d is disconnected.", c.id)
-		c.server.Err(err)
-	}
-}
-
-func (c *Client) Done() {
-	c.doneCh <- true
-}
-
-// Listen Write and Read request via chanel
-func (c *Client) Listen() {
-	go c.listenWrite()
-	c.listenRead()
-}
-
-// Listen write request via chanel
-func (c *Client) listenWrite() {
-	for {
-		select {
-
-		// send message to the client
-		case msg := <-c.ch:
-			wslogger.Debugln("Send:", msg)
-			ws.JSON.Send(c.ws, msg)
-
-		// receive done request
-		case <-c.doneCh:
-			c.server.Del(c)
-			c.doneCh <- true // for listenRead method
-			return
-		}
-	}
-}
-
-// Listen read request via chanel
-func (c *Client) listenRead() {
-	for {
-		select {
-
-		// receive done request
-		case <-c.doneCh:
-			c.server.Del(c)
-			c.doneCh <- true // for listenWrite method
-			return
-
-		// read data from ws connection
-		default:
-			var msg Message
-			err := ws.JSON.Receive(c.ws, &msg)
-			if err == io.EOF {
-				c.doneCh <- true
-			} else if err != nil {
-				c.server.Err(err)
-			} else {
-				wslogger.Debugln(&msg)
-				if c.onMessage != nil {
-					c.onMessage(c, &msg)
-				}
-			}
-		}
-	}
-}

websocket/message.go

-package websocket
-
-import "github.com/ethereum/go-ethereum/ethutil"
-
-type Message struct {
-	Call  string        `json:"call"`
-	Args  []interface{} `json:"args"`
-	Id    int           `json:"_id"`
-	Data  interface{}   `json:"data"`
-	Event string        `json:"_event"`
-}
-
-func (self *Message) Arguments() *ethutil.Value {
-	return ethutil.NewValue(self.Args)
-}

websocket/server.go

-package websocket
-
-import (
-	"net/http"
-
-	"github.com/ethereum/go-ethereum/logger"
-
-	ws "code.google.com/p/go.net/websocket"
-)
-
-var wslogger = logger.NewLogger("WS")
-
-// Chat server.
-type Server struct {
-	httpServ  string
-	pattern   string
-	messages  []*Message
-	clients   map[int]*Client
-	addCh     chan *Client
-	delCh     chan *Client
-	sendAllCh chan string
-	doneCh    chan bool
-	errCh     chan error
-	msgFunc   MsgFunc
-}
-
-// Create new chat server.
-func NewServer(pattern, httpServ string) *Server {
-	clients := make(map[int]*Client)
-	addCh := make(chan *Client)
-	delCh := make(chan *Client)
-	sendAllCh := make(chan string)
-	doneCh := make(chan bool)
-	errCh := make(chan error)
-
-	return &Server{
-		httpServ,
-		pattern,
-		nil,
-		clients,
-		addCh,
-		delCh,
-		sendAllCh,
-		doneCh,
-		errCh,
-		nil,
-	}
-}
-
-func (s *Server) Add(c *Client) {
-	s.addCh <- c
-}
-
-func (s *Server) Del(c *Client) {
-	s.delCh <- c
-}
-
-func (s *Server) SendAll(msg string) {
-	s.sendAllCh <- msg
-}
-
-func (s *Server) Done() {
-	s.doneCh <- true
-}
-
-func (s *Server) Err(err error) {
-	s.errCh <- err
-}
-
-func (s *Server) servHTTP() {
-	wslogger.Debugln("Serving http", s.httpServ)
-	err := http.ListenAndServe(s.httpServ, nil)
-
-	wslogger.Warnln(err)
-}
-
-func (s *Server) MessageFunc(f MsgFunc) {
-	s.msgFunc = f
-}
-
-// Listen and serve.
-// It serves client connection and broadcast request.
-func (s *Server) Listen() {
-	// ws handler
-	onConnected := func(ws *ws.Conn) {
-		defer func() {
-			err := ws.Close()
-			if err != nil {
-				s.errCh <- err
-			}
-		}()
-
-		client := NewClient(ws, s)
-		client.onMessage = s.msgFunc
-		s.Add(client)
-		client.Listen()
-	}
-	// Disable Origin check. Request don't need to come necessarily from origin.
-	http.HandleFunc(s.pattern, func(w http.ResponseWriter, req *http.Request) {
-		s := ws.Server{Handler: ws.Handler(onConnected)}
-		s.ServeHTTP(w, req)
-	})
-	wslogger.Debugln("Created handler")
-
-	go s.servHTTP()
-
-	for {
-		select {
-
-		// Add new a client
-		case c := <-s.addCh:
-			s.clients[c.id] = c
-
-		// del a client
-		case c := <-s.delCh:
-			delete(s.clients, c.id)
-
-		case err := <-s.errCh:
-			wslogger.Debugln("Error:", err.Error())
-
-		case <-s.doneCh:
-			return
-		}
-	}
-}

websocket/util.go

-/*
-  This file is part of go-ethereum
-
-  go-ethereum is free software: you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation, either version 3 of the License, or
-  (at your option) any later version.
-
-  go-ethereum is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License
-  along with go-ethereum.  If not, see <http://www.gnu.org/licenses/>.
-*/
-package websocket
-
-import (
-	"github.com/ethereum/go-ethereum/core"
-	"github.com/ethereum/go-ethereum/core/types"
-	"github.com/ethereum/go-ethereum/eth"
-	"github.com/ethereum/go-ethereum/ethutil"
-	"github.com/ethereum/go-ethereum/event/filter"
-	"github.com/ethereum/go-ethereum/state"
-	"github.com/ethereum/go-ethereum/ui"
-	"github.com/ethereum/go-ethereum/xeth"
-)
-
-func args(v ...interface{}) []interface{} {
-	return v
-}
-
-type WebSocketServer struct {
-	eth           *eth.Ethereum
-	filterManager *filter.FilterManager
-}
-
-func NewWebSocketServer(eth *eth.Ethereum) *WebSocketServer {
-	filterManager := filter.NewFilterManager(eth.EventMux())
-	go filterManager.Start()
-
-	return &WebSocketServer{eth, filterManager}
-}
-
-func (self *WebSocketServer) Serv() {
-	pipe := xeth.NewJSXEth(self.eth)
-
-	wsServ := NewServer("/eth", ":40404")
-	wsServ.MessageFunc(func(c *Client, msg *Message) {
-		switch msg.Call {
-		case "compile":
-			data := ethutil.NewValue(msg.Args)
-			bcode, err := ethutil.Compile(data.Get(0).Str(), false)
-			if err != nil {
-				c.Write(args(nil, err.Error()), msg.Id)
-			}
-
-			code := ethutil.Bytes2Hex(bcode)
-			c.Write(args(code, nil), msg.Id)
-		case "eth_blockByNumber":
-			args := msg.Arguments()
-
-			block := pipe.BlockByNumber(int32(args.Get(0).Uint()))
-			c.Write(block, msg.Id)
-
-		case "eth_blockByHash":
-			args := msg.Arguments()
-
-			c.Write(pipe.BlockByHash(args.Get(0).Str()), msg.Id)
-
-		case "eth_transact":
-			if mp, ok := msg.Args[0].(map[string]interface{}); ok {
-				object := mapToTxParams(mp)
-				c.Write(
-					args(pipe.Transact(pipe.Key().PrivateKey, object["to"], object["value"], object["gas"], object["gasPrice"], object["data"])),
-					msg.Id,
-				)
-
-			}
-		case "eth_gasPrice":
-			c.Write("10000000000000", msg.Id)
-		case "eth_coinbase":
-			c.Write(pipe.CoinBase(), msg.Id)
-
-		case "eth_listening":
-			c.Write(pipe.IsListening(), msg.Id)
-
-		case "eth_mining":
-			c.Write(pipe.IsMining(), msg.Id)
-
-		case "eth_peerCount":
-			c.Write(pipe.PeerCount(), msg.Id)
-
-		case "eth_countAt":
-			args := msg.Arguments()
-
-			c.Write(pipe.TxCountAt(args.Get(0).Str()), msg.Id)
-
-		case "eth_codeAt":
-			args := msg.Arguments()
-
-			c.Write(len(pipe.CodeAt(args.Get(0).Str())), msg.Id)
-
-		case "eth_storageAt":
-			args := msg.Arguments()
-
-			c.Write(pipe.StorageAt(args.Get(0).Str(), args.Get(1).Str()), msg.Id)
-
-		case "eth_balanceAt":
-			args := msg.Arguments()
-
-			c.Write(pipe.BalanceAt(args.Get(0).Str()), msg.Id)
-
-		case "eth_accounts":
-			c.Write(pipe.Accounts(), msg.Id)
-
-		case "eth_newFilter":
-			if mp, ok := msg.Args[0].(map[string]interface{}); ok {
-				var id int
-				filter := ui.NewFilterFromMap(mp, self.eth)
-				filter.LogsCallback = func(logs state.Logs) {
-					//c.Event(toMessages(messages), "eth_changed", id)
-				}
-				id = self.filterManager.InstallFilter(filter)
-				c.Write(id, msg.Id)
-			}
-		case "eth_newFilterString":
-			var id int
-			filter := core.NewFilter(self.eth)
-			filter.BlockCallback = func(block *types.Block) {
-				c.Event(nil, "eth_changed", id)
-			}
-			id = self.filterManager.InstallFilter(filter)
-			c.Write(id, msg.Id)
-		case "eth_filterLogs":
-			filter := self.filterManager.GetFilter(int(msg.Arguments().Get(0).Uint()))
-			if filter != nil {
-				//c.Write(toMessages(filter.Find()), msg.Id)
-			}
-		}
-
-	})
-
-	wsServ.Listen()
-}
-
-func toMessages(messages state.Messages) (msgs []xeth.JSMessage) {
-	msgs = make([]xeth.JSMessage, len(messages))
-	for i, msg := range messages {
-		msgs[i] = xeth.NewJSMessage(msg)
-	}
-
-	return
-}
-
-// TODO This is starting to become a generic method. Move to utils
-func mapToTxParams(object map[string]interface{}) map[string]string {
-	// Default values
-	if object["from"] == nil {
-		object["from"] = ""
-	}
-	if object["to"] == nil {
-		object["to"] = ""
-	}
-	if object["value"] == nil {
-		object["value"] = ""
-	}
-	if object["gas"] == nil {
-		object["gas"] = ""
-	}
-	if object["gasPrice"] == nil {
-		object["gasPrice"] = ""
-	}
-
-	var dataStr string
-	var data []string
-	if str, ok := object["data"].(string); ok {
-		data = []string{str}
-	}
-
-	for _, str := range data {
-		if ethutil.IsHex(str) {
-			str = str[2:]
-
-			if len(str) != 64 {
-				str = ethutil.LeftPadString(str, 64)
-			}
-		} else {
-			str = ethutil.Bytes2Hex(ethutil.LeftPadBytes(ethutil.Big(str).Bytes(), 32))
-		}
-
-		dataStr += str
-	}
-	object["data"] = dataStr
-
-	conv := make(map[string]string)
-	for key, value := range object {
-		if v, ok := value.(string); ok {
-			conv[key] = v
-		}
-	}
-
-	return conv
-}