func main() {
app := &EchoApplication{}
app.log = log.New(ioutil.Discard, "", log.LstdFlags)
//app.log = log.New(os.Stdout, "", log.LstdFlags)
router.AddRoute(enum.BeginStringFIX40, "D", app.processMsg)
router.AddRoute(enum.BeginStringFIX41, "D", app.processMsg)
router.AddRoute(enum.BeginStringFIX42, "D", app.processMsg)
router.AddRoute(enum.BeginStringFIX43, "D", app.processMsg)
router.AddRoute(enum.BeginStringFIX44, "D", app.processMsg)
router.AddRoute(string(enum.ApplVerID_FIX50), "D", app.processMsg)
router.AddRoute(string(enum.ApplVerID_FIX50SP1), "D", app.processMsg)
router.AddRoute(string(enum.ApplVerID_FIX50SP2), "D", app.processMsg)
router.AddRoute(enum.BeginStringFIX42, "d", app.processMsg)
router.AddRoute(enum.BeginStringFIX43, "d", app.processMsg)
router.AddRoute(enum.BeginStringFIX44, "d", app.processMsg)
router.AddRoute(string(enum.ApplVerID_FIX50), "d", app.processMsg)
router.AddRoute(string(enum.ApplVerID_FIX50SP1), "d", app.processMsg)
router.AddRoute(string(enum.ApplVerID_FIX50SP2), "d", app.processMsg)
cfg, err := os.Open(os.Args[1])
if err != nil {
fmt.Printf("Error opening %v, %v\n", os.Args[1], err)
return
}
appSettings, err := quickfix.ParseSettings(cfg)
if err != nil {
fmt.Println("Error reading cfg:", err)
return
}
fileLogFactory, err := quickfix.NewFileLogFactory(appSettings)
if err != nil {
fmt.Println("Error creating file log factory:", err)
return
}
acceptor, err := quickfix.NewAcceptor(app, quickfix.NewMemoryStoreFactory(), appSettings, fileLogFactory)
if err != nil {
fmt.Println("Unable to create Acceptor: ", err)
return
}
if err = acceptor.Start(); err != nil {
fmt.Println("Unable to start Acceptor: ", err)
return
}
interrupt := make(chan os.Signal)
signal.Notify(interrupt)
<-interrupt
acceptor.Stop()
}
func main() {
app := &EchoApplication{}
app.log = log.New(ioutil.Discard, "", log.LstdFlags)
//app.log = log.New(os.Stdout, "", log.LstdFlags)
router.AddRoute(fix40nos.Route(app.OnFIX40NewOrderSingle))
router.AddRoute(fix41nos.Route(app.OnFIX41NewOrderSingle))
router.AddRoute(fix42nos.Route(app.OnFIX42NewOrderSingle))
router.AddRoute(fix43nos.Route(app.OnFIX43NewOrderSingle))
router.AddRoute(fix44nos.Route(app.OnFIX44NewOrderSingle))
router.AddRoute(fix50nos.Route(app.OnFIX50NewOrderSingle))
router.AddRoute(fix50sp1nos.Route(app.OnFIX50SP1NewOrderSingle))
router.AddRoute(fix50sp2nos.Route(app.OnFIX50SP2NewOrderSingle))
router.AddRoute(fix42secdef.Route(app.OnFIX42SecurityDefinition))
router.AddRoute(fix43secdef.Route(app.OnFIX43SecurityDefinition))
router.AddRoute(fix44secdef.Route(app.OnFIX44SecurityDefinition))
router.AddRoute(fix50secdef.Route(app.OnFIX50SecurityDefinition))
router.AddRoute(fix50sp1secdef.Route(app.OnFIX50SP1SecurityDefinition))
router.AddRoute(fix50sp2secdef.Route(app.OnFIX50SP2SecurityDefinition))
cfg, err := os.Open(os.Args[1])
if err != nil {
fmt.Printf("Error opening %v, %v\n", os.Args[1], err)
return
}
appSettings, err := quickfix.ParseSettings(cfg)
if err != nil {
fmt.Println("Error reading cfg:", err)
return
}
fileLogFactory, err := quickfix.NewFileLogFactory(appSettings)
if err != nil {
fmt.Println("Error creating file log factory:", err)
return
}
acceptor, err := quickfix.NewAcceptor(app, quickfix.NewMemoryStoreFactory(), appSettings, fileLogFactory)
if err != nil {
fmt.Println("Unable to create Acceptor: ", err)
return
}
if err = acceptor.Start(); err != nil {
fmt.Println("Unable to start Acceptor: ", err)
return
}
interrupt := make(chan os.Signal)
signal.Notify(interrupt)
<-interrupt
acceptor.Stop()
}
func main() {
app := app.NewInitiatorApp()
cfg, _ := os.Open("whygo/cfg/initiator.cfg")
storeFactory := quickfix.NewMemoryStoreFactory()
appSettings, _ := quickfix.ParseSettings(cfg)
logFactory, _ := quickfix.NewFileLogFactory(appSettings)
initiator, _ := quickfix.NewInitiator(app, storeFactory, appSettings, logFactory)
initiator.Start()
app.Run()
}
func main() {
cfgFileName := "tradeclient.cfg"
cfg, err := os.Open(cfgFileName)
if err != nil {
fmt.Printf("Error opening %v, %v\n", cfgFileName, err)
return
}
appSettings, err := quickfix.ParseSettings(cfg)
if err != nil {
fmt.Println("Error reading cfg,", err)
return
}
app := TradeClient{}
fileLogFactory, err := quickfix.NewFileLogFactory(appSettings)
if err != nil {
fmt.Println("Error creating file log factory,", err)
return
}
initiator, err := quickfix.NewInitiator(app, quickfix.NewMemoryStoreFactory(), appSettings, fileLogFactory)
if err != nil {
fmt.Printf("Unable to create Initiator: %s\n", err)
return
}
initiator.Start()
for {
action, err := queryAction()
if err != nil {
break
}
switch action {
case "1":
err = queryEnterOrder()
default:
err = fmt.Errorf("unknown action: '%v'", action)
}
if err != nil {
fmt.Printf("%v\n", err)
break
}
}
initiator.Stop()
}
func main() {
app := app.NewAcceptorApp()
cfg, _ := os.Open("whygo/cfg/acceptor.cfg")
storeFactory := quickfix.NewMemoryStoreFactory()
appSettings, _ := quickfix.ParseSettings(cfg)
logFactory, _ := quickfix.NewFileLogFactory(appSettings)
acceptor, _ := quickfix.NewAcceptor(app, storeFactory, appSettings, logFactory)
acceptor.Start()
interrupt := make(chan os.Signal)
signal.Notify(interrupt)
<-interrupt
}
func main() {
flag.Parse()
cfg, err := os.Open(*fixconfig)
if err != nil {
log.Fatal(err)
}
appSettings, err := quickfix.ParseSettings(cfg)
if err != nil {
log.Fatal(err)
}
logFactory, err := quickfix.NewFileLogFactory(appSettings)
if err != nil {
log.Fatal(err)
}
initiator, err := quickfix.NewInitiator(app, appSettings, logFactory)
if err != nil {
log.Fatal(err)
}
if err = initiator.Start(); err != nil {
log.Fatal(err)
}
<-start
for i := 0; i < *sampleSize; i++ {
order := newordersingle.Builder(
field.NewClOrdID("100"),
field.NewHandlInst("1"),
field.NewSymbol("TSLA"),
field.NewSide(enum.Side_BUY),
&field.TransactTimeField{},
field.NewOrdType(enum.OrdType_MARKET))
quickfix.SendToTarget(order, SessionID)
time.Sleep(1 * time.Millisecond)
}
time.Sleep(2 * time.Second)
}
func main() {
cfgFileName := "executor.cfg"
cfg, err := os.Open(cfgFileName)
if err != nil {
fmt.Printf("Error opening %v, %v\n", cfgFileName, err)
return
}
appSettings, err := quickfix.ParseSettings(cfg)
if err != nil {
fmt.Println("Error reading cfg,", err)
return
}
fileLogFactory, err := quickfix.NewFileLogFactory(appSettings)
if err != nil {
fmt.Println("Error creating file log factory,", err)
return
}
app := NewExecutor()
acceptor, err := quickfix.NewAcceptor(app, quickfix.NewMemoryStoreFactory(), appSettings, fileLogFactory)
if err != nil {
fmt.Printf("Unable to create Acceptor: %s\n", err)
return
}
acceptor.Start()
interrupt := make(chan os.Signal)
signal.Notify(interrupt)
<-interrupt
acceptor.Stop()
}
func main() {
flag.Parse()
cfgFileName := path.Join("config", "tradeclient.cfg")
if flag.NArg() > 0 {
cfgFileName = flag.Arg(0)
}
cfg, err := os.Open(cfgFileName)
if err != nil {
fmt.Printf("Error opening %v, %v\n", cfgFileName, err)
return
}
appSettings, err := quickfix.ParseSettings(cfg)
if err != nil {
fmt.Println("Error reading cfg,", err)
return
}
app := TradeClient{}
fileLogFactory, err := quickfix.NewFileLogFactory(appSettings)
if err != nil {
fmt.Println("Error creating file log factory,", err)
return
}
initiator, err := quickfix.NewInitiator(app, quickfix.NewMemoryStoreFactory(), appSettings, fileLogFactory)
if err != nil {
fmt.Printf("Unable to create Initiator: %s\n", err)
return
}
initiator.Start()
Loop:
for {
action, err := internal.QueryAction()
if err != nil {
break
}
switch action {
case "1":
err = internal.QueryEnterOrder()
case "2":
err = internal.QueryCancelOrder()
case "3":
err = internal.QueryMarketDataRequest()
case "4":
//quit
break Loop
default:
err = fmt.Errorf("unknown action: '%v'", action)
}
if err != nil {
fmt.Printf("%v\n", err)
}
}
initiator.Stop()
}