// GetBroadcastClient creates a simple instance of the BroadcastClient interface
func GetBroadcastClient() (BroadcastClient, error) {
var orderer string
if viper.GetBool("peer.committer.enabled") {
orderer = viper.GetString("peer.committer.ledger.orderer")
}
if orderer == "" {
return nil, fmt.Errorf("Can't get orderer address")
}
var opts []grpc.DialOption
opts = append(opts, grpc.WithInsecure())
opts = append(opts, grpc.WithTimeout(3*time.Second))
opts = append(opts, grpc.WithBlock())
conn, err := grpc.Dial(orderer, opts...)
if err != nil {
return nil, fmt.Errorf("Error connecting to %s due to %s", orderer, err)
}
client, err := ab.NewAtomicBroadcastClient(conn).Broadcast(context.TODO())
if err != nil {
conn.Close()
return nil, fmt.Errorf("Error connecting to %s due to %s", orderer, err)
}
return &broadcastClient{conn: conn, client: client}, nil
}
func main() {
config := config.Load()
var chainID string
var serverAddr string
var windowSize uint64
flag.StringVar(&serverAddr, "server", fmt.Sprintf("%s:%d", config.General.ListenAddress, config.General.ListenPort), "The RPC server to connect to.")
flag.StringVar(&chainID, "chainID", provisional.TestChainID, "The chain ID to deliver from.")
flag.Uint64Var(&windowSize, "windowSize", 10, "The window size for the deliver.")
flag.Parse()
conn, err := grpc.Dial(serverAddr, grpc.WithInsecure())
if err != nil {
fmt.Println("Error connecting:", err)
return
}
client, err := ab.NewAtomicBroadcastClient(conn).Deliver(context.TODO())
if err != nil {
fmt.Println("Error connecting:", err)
return
}
s := newDeliverClient(client, chainID, windowSize)
s.seekOldest()
s.readUntilClose()
}
func TestSbftPeer(t *testing.T) {
tempDir, err := ioutil.TempDir("", "sbft_test")
if err != nil {
panic("Failed to create a temporary directory")
}
// We only need the path as the directory will be created
// by the peer - TODO: modify sbft to tolerate an existing
// directory
os.RemoveAll(tempDir)
defer func() {
os.RemoveAll(tempDir)
}()
c := flags{init: "testdata/config.json",
listenAddr: ":6101",
grpcAddr: ":7101",
certFile: "testdata/cert1.pem",
keyFile: "testdata/key.pem",
dataDir: tempDir}
logger.Info("Initialization of instance.")
err = initInstance(c)
if err != nil {
t.Errorf("Initialization failed: %s", err)
return
}
logging.SetLevel(logging.DEBUG, "")
logger.Info("Starting an instance in the background.")
go serve(c)
<-time.After(5 * time.Second)
logger.Info("Creating an Atomic Broadcast GRPC connection.")
timeout := 4 * time.Second
clientconn, err := grpc.Dial(":7101", grpc.WithBlock(), grpc.WithTimeout(timeout), grpc.WithInsecure())
if err != nil {
t.Errorf("Failed to connect to GRPC: %s", err)
return
}
client := ab.NewAtomicBroadcastClient(clientconn)
resultch := make(chan byte)
errorch := make(chan error)
logger.Info("Starting a goroutine waiting for ledger updates.")
go updateReceiver(t, resultch, errorch, client)
logger.Info("Starting a single broadcast sender goroutine.")
go broadcastSender(t, resultch, errorch, client)
checkResults(t, resultch, errorch)
}
func main() {
var loglevel string
client := &clientImpl{doneChan: make(chan struct{})}
backend := logging.NewLogBackend(os.Stderr, "", 0)
logging.SetBackend(backend)
formatter := logging.MustStringFormatter("[%{time:15:04:05}] %{shortfile:18s}: %{color}[%{level:-5s}]%{color:reset} %{message}")
logging.SetFormatter(formatter)
logger = logging.MustGetLogger(pkgName)
flag.StringVar(&loglevel, "loglevel", "info",
"The logging level. (Suggested values: info, debug)")
flag.StringVar(&client.config.server, "server",
"127.0.0.1:7050", "The RPC server to connect to.")
flag.StringVar(&client.config.cmd.cmd, "cmd", "new-chain",
"The action that this client is requesting via the config transaction.")
flag.StringVar(&client.config.cmd.args.creationPolicy, "creationPolicy", "AcceptAllPolicy",
"In case of a new-chain command, the chain createion policy this request should be validated against.")
flag.StringVar(&client.config.cmd.args.chainID, "chainID", "NewChainID",
"In case of a new-chain command, the chain ID to create.")
flag.Parse()
client.config.logLevel, _ = logging.LogLevel(strings.ToUpper(loglevel))
logging.SetLevel(client.config.logLevel, logger.Module)
conn, err := grpc.Dial(client.config.server, grpc.WithInsecure())
if err != nil {
logger.Fatalf("Client did not connect to %s: %v", client.config.server, err)
}
defer conn.Close()
client.rpc = ab.NewAtomicBroadcastClient(conn)
switch client.config.cmd.cmd {
case "new-chain":
envelope := newChainRequest(client.config.cmd.args.creationPolicy, client.config.cmd.args.chainID)
logger.Infof("Requesting the creation of chain \"%s\"", client.config.cmd.args.chainID)
client.broadcast(envelope)
default:
panic("Invalid cmd given")
}
}
func main() {
logger.Info("Creating an Atomic Broadcast GRPC connection.")
timeout := 4 * time.Second
clientconn, err := grpc.Dial(":7101", grpc.WithBlock(), grpc.WithTimeout(timeout), grpc.WithInsecure())
if err != nil {
logger.Errorf("Failed to connect to GRPC: %s", err)
return
}
client := ab.NewAtomicBroadcastClient(clientconn)
resultch := make(chan byte)
errorch := make(chan error)
logger.Info("Starting a goroutine waiting for ledger updates.")
go updateReceiver(resultch, errorch, client)
logger.Info("Starting a single broadcast sender goroutine.")
go broadcastSender(resultch, errorch, client)
checkResults(resultch, errorch)
}
func (d *DeliverService) initDeliver() error {
opts := []grpc.DialOption{grpc.WithInsecure(), grpc.WithTimeout(3 * time.Second), grpc.WithBlock()}
endpoint := viper.GetString("peer.committer.ledger.orderer")
conn, err := grpc.Dial(endpoint, opts...)
if err != nil {
logger.Errorf("Cannot dial to %s, because of %s", endpoint, err)
return err
}
var abc orderer.AtomicBroadcast_DeliverClient
abc, err = orderer.NewAtomicBroadcastClient(conn).Deliver(context.TODO())
if err != nil {
logger.Errorf("Unable to initialize atomic broadcast, due to %s", err)
return err
}
// Atomic Broadcast Deliver Client
d.client = abc
d.conn = conn
return nil
}