func main() {
flag.Parse()
ch, err := tchannel.NewChannel("ping", nil)
if err != nil {
log.Fatalf("channel did not create successfully: %v", err)
}
logger := log.StandardLogger()
worker := &worker{
channel: ch,
ringpop: ringpop.NewRingpop("ping-app", *hostport, ch, &ringpop.Options{
Logger: bark.NewLoggerFromLogrus(logger),
}),
logger: logger,
}
if err := worker.RegisterPong(); err != nil {
log.Fatalf("could not register pong handler: %v", err)
}
if err := worker.channel.ListenAndServe(*hostport); err != nil {
log.Fatalf("could not listen on given hostport: %v", err)
}
opts := new(ringpop.BootstrapOptions)
opts.File = *hostfile
if _, err := worker.ringpop.Bootstrap(opts); err != nil {
log.Fatalf("ringpop bootstrap failed: %v", err)
}
select {}
}
func TestGetFields(t *testing.T) {
var logger bark.Logger
// Plain logger
logger = bark.NewLoggerFromLogrus(logrus.New())
require.Equal(t, logger.Fields(), bark.Fields(nil))
// Add nil, don't crash
logger = bark.NewLoggerFromLogrus(logrus.New())
logger = logger.WithFields(nil)
require.Equal(t, logger.Fields(), bark.Fields(nil))
// One field added
logger = bark.NewLoggerFromLogrus(logrus.New())
logger = logger.WithField("foo", "bar")
require.Equal(t, logger.Fields(), bark.Fields{"foo": "bar"})
// Two fields added at once
logger = bark.NewLoggerFromLogrus(logrus.New())
logger = logger.WithFields(bark.Fields{"foo": "bar", "baz": "bump"})
require.Equal(t, logger.Fields(), bark.Fields{"foo": "bar", "baz": "bump"})
// One then one
logger = bark.NewLoggerFromLogrus(logrus.New())
logger = logger.WithField("foo", "bar")
logger = logger.WithField("baz", "bump")
require.Equal(t, logger.Fields(), bark.Fields{"foo": "bar", "baz": "bump"})
// Two then one
logger = bark.NewLoggerFromLogrus(logrus.New())
logger = logger.WithFields(bark.Fields{"foo": "bar", "baz": "bump"})
logger = logger.WithField("x", "y")
require.Equal(t, logger.Fields(), bark.Fields{"foo": "bar", "baz": "bump", "x": "y"})
// One then two
logger = bark.NewLoggerFromLogrus(logrus.New())
logger = logger.WithField("x", "y")
logger = logger.WithFields(bark.Fields{"foo": "bar", "baz": "bump"})
require.Equal(t, logger.Fields(), bark.Fields{"foo": "bar", "baz": "bump", "x": "y"})
// Two then two
logger = bark.NewLoggerFromLogrus(logrus.New())
logger = logger.WithFields(bark.Fields{"foo": "bar", "baz": "bump"})
logger = logger.WithFields(bark.Fields{"a": "b", "c": "d"})
require.Equal(t, logger.Fields(), bark.Fields{"foo": "bar", "baz": "bump", "a": "b", "c": "d"})
// Add empty map
logger = bark.NewLoggerFromLogrus(logrus.New())
logger = logger.WithFields(bark.Fields{})
require.Equal(t, logger.Fields(), bark.Fields{})
}
func newWorker(address string, channel *tchannel.Channel) *worker {
logger := bark.NewLoggerFromLogrus(logrus.StandardLogger())
return &worker{
address: address,
ringpop: ringpop.NewRingpop("pingpong", address, channel, &ringpop.Options{
Logger: logger,
}),
}
}
// NewForwarder returns a new forwarder
func NewForwarder(s Sender, ch tchannel.Registrar, logger log.Logger) *Forwarder {
if logger == nil {
logger = log.NewLoggerFromLogrus(&logrus.Logger{
Out: ioutil.Discard,
})
}
return &Forwarder{
sender: s,
channel: ch,
logger: logger,
}
}
func defaultOptions() *Options {
logger := log.NewLoggerFromLogrus(&logrus.Logger{
Out: ioutil.Discard,
})
opts := &Options{
Logger: logger,
Statter: new(noopStatsReporter),
ReplicaPoints: 100,
}
return opts
}
// NewReplicator returns a new Replicator instance that makes calls with the given
// SubChannel to the service defined by SubChannel.GetServiceName(). The given n/w/r
// values will be used as defaults for the replicator when none are provided
func NewReplicator(s Sender, channel tchannel.Registrar, logger log.Logger,
opts *Options) *Replicator {
if logger == nil {
logger = log.NewLoggerFromLogrus(&logrus.Logger{
Out: ioutil.Discard,
})
}
f := forward.NewForwarder(s, channel, logger)
opts = mergeDefaultOptions(opts, &Options{3, 1, 3, Parallel})
return &Replicator{s, channel, f, logger, opts}
}
func main() {
var logrusLogger *logrus.Logger = logrus.New()
logrusLogger.Formatter = new(logrus.JSONFormatter)
if len(os.Args) != 2 {
logrus.Error("Must pass an arg to test program...")
os.Exit(0)
}
switch os.Args[1] {
case "logrus.Fatal":
logrusLogger.Fatal("fatal error")
case "logrus.Fatalf":
logrusLogger.Fatalf("fatal error%s", "fatal error")
case "bark.Fatal":
bark.NewLoggerFromLogrus(logrusLogger).Fatal("fatal error")
case "bark.Fatalf":
bark.NewLoggerFromLogrus(logrusLogger).Fatalf("fatal error%s", "fatal error")
}
logrus.Error("Expected fatal methods to exit...")
os.Exit(0)
}
func newWorker(address string, channel *tchannel.Channel) *worker {
logger := bark.NewLoggerFromLogrus(logrus.StandardLogger())
rp, err := ringpop.New("pingpong",
ringpop.Channel(channel),
ringpop.Identity(address),
ringpop.Logger(logger),
)
if err != nil {
log.Fatalf("Unable to create Ringpop: %v", err)
}
return &worker{
address: address,
ringpop: rp,
}
}
func main() {
flag.Parse()
ch, err := tchannel.NewChannel("ping", nil)
if err != nil {
log.Fatalf("channel did not create successfully: %v", err)
}
logger := log.StandardLogger()
rp, err := ringpop.New("ping-app",
ringpop.Channel(ch),
ringpop.Identity(*hostport),
ringpop.Logger(bark.NewLoggerFromLogrus(logger)),
)
if err != nil {
log.Fatalf("Unable to create Ringpop: %v", err)
}
worker := &worker{
channel: ch,
ringpop: rp,
logger: logger,
}
if err := worker.RegisterPong(); err != nil {
log.Fatalf("could not register pong handler: %v", err)
}
if err := worker.channel.ListenAndServe(*hostport); err != nil {
log.Fatalf("could not listen on given hostport: %v", err)
}
opts := new(swim.BootstrapOptions)
opts.File = *hostfile
if _, err := worker.ringpop.Bootstrap(opts); err != nil {
log.Fatalf("ringpop bootstrap failed: %v", err)
}
select {}
}
func createCluster(hostport string, seednodes []string, app clusterApp) *cluster {
channel, err := tchannel.NewChannel("kbase", nil)
if err != nil {
log.Fatalf("channel did not create successfully: %v", err)
}
ringpop, err := ringpop.New("kbase-app",
ringpop.Channel(channel),
ringpop.Identity(hostport),
ringpop.Logger(bark.NewLoggerFromLogrus(log)),
)
if err != nil {
log.Fatalf("Unable to create Ringpop: %v", err)
}
if err := channel.ListenAndServe(hostport); err != nil {
log.Fatalf("could not listen on given hostport: %v", err)
}
opts := new(swim.BootstrapOptions)
if len(seednodes) > 0 {
opts.Hosts = seednodes
}
if _, err := ringpop.Bootstrap(opts); err != nil {
log.Fatalf("ringpop bootstrap failed: %v", err)
}
cluster := &cluster{
/*ring: Ring{
hcodes: []int{},
servers: make(map[int]string),
},*/
ringpop: ringpop,
channel: channel,
app: app}
ringpop.RegisterListener(cluster)
return cluster
}
func main() {
verbose := flag.Bool("verbose", false, "enable debug level logging")
flag.Parse()
if !hostportPattern.MatchString(*hostport) {
log.Fatalf("bad hostport: %s", *hostport)
}
ch, err := tchannel.NewChannel("ringpop", nil)
if err != nil {
log.Fatalf("could not create channel: %v", err)
}
logger := log.StandardLogger()
if *verbose {
logger.Level = log.DebugLevel
}
rp, _ := ringpop.New("ringpop",
ringpop.Channel(ch),
ringpop.Identity(*hostport),
ringpop.Logger(bark.NewLoggerFromLogrus(logger)),
)
if err := ch.ListenAndServe(*hostport); err != nil {
log.Fatalf("could not listen on %s: %v", *hostport, err)
}
opts := &swim.BootstrapOptions{}
opts.File = *hostfile
_, err = rp.Bootstrap(opts)
if err != nil {
log.Fatalf("bootstrap failed: %v", err)
}
// block
select {}
}
func defaultOptions() *Options {
opts := &Options{
BootstrapFile: "./hosts.json",
SuspicionTimeout: 5000 * time.Millisecond,
MinProtocolPeriod: 200 * time.Millisecond,
JoinTimeout: 1000 * time.Millisecond,
PingTimeout: 1500 * time.Millisecond,
PingRequestTimeout: 5000 * time.Millisecond,
PingRequestSize: 3,
RollupFlushInterval: 5000 * time.Millisecond,
RollupMaxUpdates: 250,
Logger: log.NewLoggerFromLogrus(&logrus.Logger{
Out: ioutil.Discard,
}),
}
return opts
}
// Create a bark wrapper for a logrus logger backed by a buffer
func getBarkLogger() (bark.Logger, *bytes.Buffer) {
logrusLogger, buffer := getLogrusLogger()
return bark.NewLoggerFromLogrus(logrusLogger), buffer
}