Oddin.gg Golang SDK

Rest API and Streaming API for connecting to Oddin.gg services and odds Feed.

Installing

go get github.com/oddin-gg/gosdk

Example Feed client

see example feed and api client with full working demo of how to connect to Oddin.gg Feed

How to start

Prepare your configuration:

const (
	token  = "YOUR TOKEN"
	env    = protocols.IntegrationEnvironment
	nodeID = 2
)

Initialize Feed:

cfg := gosdk.NewConfiguration(token, env, nodeID, false)
feed := gosdk.NewOddsFeed(cfg)

Retrieve any manager you may need:

producerManager, err := feed.ProducerManager()
recoveryManager, err := feed.RecoveryManager()
sportsManager, err := feed.SportsInfoManager()
marketManager, err := feed.MarketDescriptionManager()
replyManager, err := feed.ReplayManager()

Build session and open the Feed:

sessionBuilder, err := feed.SessionBuilder()
sessionChannel, err := sessionBuilder.SetMessageInterest(protocols.AllMessageInterest).Build()
globalChannel, err := feed.Open()

Start listening to messages:

for {
    select {
    case sessionMsg := <-sessionChannel:
        if sessionMsg.UnparsableMessage != nil {
            log.Println("unparsed message")
            continue
        }

        requestMsg, ok := sessionMsg.Message.(protocols.RequestMessage)
        if !ok {
            log.Printf("failed to convert message to request message for client - message is %T", sessionMsg.Message)
            continue
        }

        handleFeedMessage(sessionMsg, requestMsg.RequestID())

    case feedMsg := <-feedChannel:
        if feedMsg.Recovery == nil {
            continue
        }
        handleRecoveryMessage(feedMsg.Recovery)

    case <-closeCh:
        return
    }
}

Handle Recovery messages:

func handleRecoveryMessage(recoveryMsg *protocols.RecoveryMessage) {
	if recoveryMsg.ProducerStatus != nil {
		if recoveryMsg.ProducerStatus.IsDown() {
			log.Printf("producer %d is down", recoveryMsg.ProducerStatus.Producer().ID())
			return
		}
		log.Printf("producer %d is up", recoveryMsg.ProducerStatus.Producer().ID())
	}
}

Handle Feed messages:

func handleFeedMessage(sessionMsg protocols.SessionMessage, requestID *uint) {
    if requestID == nil {
        // if producer is down, message is out of order - not recovered and no request id
        log.Print("message out of order")
    }

    switch msg := sessionMsg.Message.(type) {
    case protocols.OddsChange:
        e.processOddsChange(msg)
    case protocols.FixtureChangeMessage:
        e.processFixtureChange(msg)
    case protocols.BetCancel:
        e.processBetCancel(msg)
    case protocols.BetSettlement:
        e.processBetSettlement(msg)
    case protocols.RollbackBetSettlement:
        e.processRollbackBetSettlement(msg)
    case protocols.RollbackBetCancel:
        e.processRollbackBetCancel(msg)
    default:
        log.Printf("unknown msg type %T", msg)
    }
}

You should start receiving event odds via provided listeners.