1397

Committed 22 Jun 2020 05:29PM UTC coverage: 74.56%. First build

Build # 1397

Build Type

Pull #91

travis-ci

Committed by

web-flow

Commit Message

<a href="https://github.com/topfreegames/maestro/commit/<a class=hub.com/topfreegames/maestro/commit/<a class="double-link" href="https://git"><a class=hub.com/topfreegames/maestro/commit/<a class="double-link" href="https://git"><a class=hub.com/topfreegames/maestro/commit/<a class="double-link" href="https://git"><a class=hub.com/topfreegames/maestro/commit/<a class="double-link" href="https://git"><a class=hub.com/topfreegames/maestro/commit/4a45bd0362c639d536ab822bac11efc852c0f8a9">4a45bd036">&lt;a href=&quot;https://github.com/topfreegames/maestro/commit/</a><a class="double-link" href="https://github.com/topfreegames/maestro/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/topfreegames/maestro/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/topfreegames/maestro/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://git">&lt;a class=</a>hub.com/topfreegames/maestro/commit/4a45bd0362c639d536ab822bac11efc852c0f8a9">4a45bd036</a><a href="https://github.com/topfreegames/maestro/commit/4a45bd0362c639d536ab822bac11efc852c0f8a9">&lt;a href=&quot;https://github.com/topfreegames/maestro/commit/4a45bd0362c639d536ab822bac11efc852c0f8a9&quot;&gt;&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/topfreegames/maestro/commit/&amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/topfreegames/maestro/commit/&amp;amp;lt;a class=&amp;amp;quot;double-link&amp;amp;quot; href=&amp;amp;quot;https://git&amp;quot;&amp;gt;&amp;amp;lt;a class=&amp;lt;/a&amp;gt;hub.com/topfreegames/maestro/commit/4a45bd0362c639d536ab822bac11efc852c0f8a9&amp;quot;&amp;gt;4a45bd036&amp;lt;/a&amp;gt;&amp;lt;a href=&amp;quot;https://github.com/topfreegames/maestro/commit/4a45bd0362c639d536ab822bac11efc852c0f8a9&amp;quot;&amp;gt;&amp;amp;lt;a href=&amp;amp;quot;https://github.com/topfreegames/maestro/commit/4a45bd0362c639d536ab822bac11efc8&amp;lt;/a&amp;gt;52c0f8a9</a>&quot;&gt;&amp;quot;&amp;gt;Merge &amp;lt;/a&amp;gt;&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/topfreegames/maestro/commit/&amp;lt;a class=&amp;quot;double-link&amp;quot; href=&amp;quot;https://github.com/topfreegames/maestro/commit/&lt;a class=&quot;double-link&quot; href=&quot;https://github.com/topfreegames/maestro/commit/cbf5436e0... (continued)

Pull Request Pull Request #91: Fix maestro tests

Run Details

18 of 18 new or added lines in 6 files covered. (100.0%)

6940 of 9308 relevant lines covered (74.56%)

80.2 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.19

/eventforwarder/forward.go

package eventforwarder

import (
        "context"
        "fmt"
        "os"
        "strings"
        "time"

        "github.com/sirupsen/logrus"
        pginterfaces "github.com/topfreegames/extensions/pg/interfaces"
        redisinterfaces "github.com/topfreegames/extensions/redis/interfaces"
        "github.com/topfreegames/maestro/models"
        "github.com/topfreegames/maestro/reporters"
        reportersConstants "github.com/topfreegames/maestro/reporters/constants"
        "k8s.io/client-go/kubernetes"
)

// Response is the struct that defines a forwarder response
type Response struct {
        Code    int
        Message string
}

// Forwarder is the struct that defines a forwarder with its EventForwarder as configured
// in maestro and the metadata configured for each scheduler
type Forwarder struct {
        Func     EventForwarder
        Metadata map[string]interface{}
}

func getEnabledForwarders(
        schedulerForwarders map[string]map[string]*models.Forwarder,
        configuredForwarders []*Info,
) []*Forwarder {
        enabledForwarders := make([]*Forwarder, 0)
        for _, configuredFwdInfo := range configuredForwarders {
                if schedulerFwds, ok := schedulerForwarders[configuredFwdInfo.Plugin]; ok {
                        if fwd, ok := schedulerFwds[configuredFwdInfo.Name]; ok {
                                if fwd.Enabled {
                                        enabledForwarders = append(
                                                enabledForwarders,
                                                &Forwarder{configuredFwdInfo.Forwarder, fwd.Metadata},
                                        )
                                }
                        }
                }
        }
        return enabledForwarders
}

// ForwardRoomEvent forwards room event to app eventforwarders
func ForwardRoomEvent(
        ctx context.Context,
        forwarders []*Info,
        redis redisinterfaces.RedisClient,
        db pginterfaces.DB,
        kubernetesClient kubernetes.Interface,
        mr *models.MixedMetricsReporter,
        room *models.Room,
        status string,
        eventType string,
        metadata map[string]interface{},
        schedulerCache *models.SchedulerCache,
        logger logrus.FieldLogger,
        addrGetter models.AddrGetter,
) (res *Response, err error) {
        var eventWasForwarded bool
        startTime := time.Now()
        defer func() {
                reportRPCStatus(
                        eventWasForwarded,
                        room.SchedulerName, RouteRoomEvent,
                        db,
                        schedulerCache,
                        logger,
                        err,
                        time.Now().Sub(startTime),
                )
        }()

        l := logger.WithFields(logrus.Fields{
                "op":        "forwardRoomEvent",
                "scheduler": room.SchedulerName,
                "roomId":    room.ID,
        })

        if len(metadata) == 0 {
                metadata = map[string]interface{}{}
        }

        if len(forwarders) > 0 {
                l.Debug("forwarding information to app forwarders")

                cachedScheduler, err := schedulerCache.LoadScheduler(db, room.SchedulerName, true)
                if err != nil {
                        l.WithError(err).Error("error reading scheduler from cache")
                        return nil, err
                }

                l.WithFields(logrus.Fields{
                        "schedulerForwarders": len(cachedScheduler.ConfigYAML.Forwarders),
                }).Debug("checking enabled forwarders")

                if len(cachedScheduler.ConfigYAML.Forwarders) > 0 {
                        enabledForwarders := getEnabledForwarders(cachedScheduler.ConfigYAML.Forwarders, forwarders)

                        l.WithFields(logrus.Fields{
                                "schedulerForwarders": len(cachedScheduler.ConfigYAML.Forwarders),
                                "enabledForwarders":   len(enabledForwarders),
                        }).Debug("got enabled forwarders")

                        if len(enabledForwarders) > 0 {
                                infos := map[string]interface{}{
                                        "roomId": room.ID,
                                        "game":   cachedScheduler.Scheduler.Game,
                                }
                                if eventType != PingTimeoutEvent && eventType != OccupiedTimeoutEvent {
                                        infos, err = room.GetRoomInfos(redis, db, kubernetesClient, schedulerCache, cachedScheduler.Scheduler, addrGetter, mr)

                                        if err != nil {
                                                l.WithError(err).Error("error getting room info from redis")
                                                return nil, err
                                        }
                                        reportIpv6Status(infos, logger)
                                } else { // fill host and port with zero values when pingTimeout or occupiedTimeout event so it won't break the GRPCForwarder
                                        infos["host"] = ""
                                        infos["port"] = int32(0)
                                }

                                if infos["metadata"] == nil {
                                        infos["metadata"] = make(map[string]interface{}, len(metadata))
                                }

                                for key, info := range metadata {
                                        infos["metadata"].(map[string]interface{})[key] = info
                                }
                                eventWasForwarded = true

                                return ForwardEventToForwarders(ctx, enabledForwarders, status, infos, l)
                        }
                }
        }

        l.Debug("no forwarders configured and enabled")

        return nil, nil
}

// ForwardPlayerEvent forwards player event to app eventforwarders
func ForwardPlayerEvent(
        ctx context.Context,
        forwarders []*Info,
        db pginterfaces.DB,
        kubernetesClient kubernetes.Interface,
        room *models.Room,
        event string,
        metadata map[string]interface{},
        schedulerCache *models.SchedulerCache,
        logger logrus.FieldLogger,
) (resp *Response, err error) {
        var eventWasForwarded bool
        startTime := time.Now()
        defer func() {
                reportRPCStatus(
                        eventWasForwarded,
                        room.SchedulerName, RoutePlayerEvent,
                        db,
                        schedulerCache,
                        logger,
                        err,
                        time.Now().Sub(startTime),
                )
        }()

        l := logger.WithFields(logrus.Fields{
                "op":        "forwardPlayerEvent",
                "scheduler": room.SchedulerName,
                "roomId":    room.ID,
        })
        if len(forwarders) > 0 {
                metadata["roomId"] = room.ID
                cachedScheduler, err := schedulerCache.LoadScheduler(db, room.SchedulerName, true)
                if err != nil {
                        return nil, err
                }
                metadata["game"] = cachedScheduler.Scheduler.Game
                l.WithFields(logrus.Fields{
                        "schedulerForwarders": len(cachedScheduler.ConfigYAML.Forwarders),
                }).Debug("checking enabled forwarders")
                if len(cachedScheduler.ConfigYAML.Forwarders) > 0 {
                        enabledForwarders := getEnabledForwarders(cachedScheduler.ConfigYAML.Forwarders, forwarders)
                        l.WithFields(logrus.Fields{
                                "schedulerForwarders": len(cachedScheduler.ConfigYAML.Forwarders),
                                "enabledForwarders":   len(enabledForwarders),
                        }).Debug("got enabled forwarders")
                        if len(enabledForwarders) > 0 {
                                eventWasForwarded = true
                                return ForwardEventToForwarders(ctx, enabledForwarders, event, metadata, l)
                        }
                }
        }
        l.Debug("no forwarders configured and enabled")
        return nil, nil
}

// ForwardEventToForwarders forwards
func ForwardEventToForwarders(
        ctx context.Context,
        forwarders []*Forwarder,
        event string,
        infos map[string]interface{},
        logger logrus.FieldLogger,
) (*Response, error) {
        logger.WithFields(logrus.Fields{
                "forwarders": len(forwarders),
                "infos":      infos,
                "event":      event,
        }).Debug("forwarding events")
        respCode := 0
        respMessage := []string{}
        for _, f := range forwarders {
                code, message, err := f.Func.Forward(ctx, event, infos, f.Metadata)
                if err != nil {
                        return nil, err
                }
                // return the highest code received
                // if a forwarder returns 200 and another 500 we should return 500 to indicate the error
                // TODO: consider configuring for each forwarder if its errors can be ignored
                if int(code) > respCode {
                        respCode = int(code)
                }
                if message != "" {
                        respMessage = append(respMessage, message)
                }
        }
        resp := &Response{
                Code:    respCode,
                Message: strings.Join(respMessage, ";"),
        }
        return resp, nil
}

// reportRPCStatus sends to StatsD success true if err is null
// and false otherwise
func reportRPCStatus(
        eventWasForwarded bool,
        schedulerName, forwardRoute string,
        db pginterfaces.DB,
        cache *models.SchedulerCache,
        logger logrus.FieldLogger,
        eventForwarderErr error,
        responseTime time.Duration,
) {
        if !reporters.HasReporters() {
                return
        }
        log := logger.WithField("operation", "reportRPCStatus")

        if !eventWasForwarded {
                log.Debug("no rpc was made, returning...")
                return
        }

        scheduler, err := cache.LoadScheduler(db, schedulerName, true)
        if err != nil {
                logger.
                        WithField("operation", "reportRPCStatus").
                        WithError(err).
                        Error("failed to report RPC connection to StatsD")
                return
        }

        game := scheduler.ConfigYAML.Game

        status := map[string]interface{}{
                reportersConstants.TagGame:      game,
                reportersConstants.TagScheduler: schedulerName,
                reportersConstants.TagHostname:  Hostname(),
                reportersConstants.TagRoute:     forwardRoute,
                reportersConstants.TagStatus:    "success",
        }

        if eventForwarderErr != nil {
                status[reportersConstants.TagStatus] = "failed"
                status[reportersConstants.TagReason] = eventForwarderErr.Error()
        }

        reporterErr := reporters.Report(reportersConstants.EventRPCStatus, status)
        if reporterErr != nil {
                logger.
                        WithField("operation", "reportRPCStatus").
                        WithError(err).
                        Error("failed to report RPC connection to StatsD")
        }

        status[reportersConstants.TagResponseTime] = responseTime.String()
        reporterErr = reporters.Report(reportersConstants.EventRPCDuration, status)
        if reporterErr != nil {
                logger.
                        WithField("operation", "reportRPCDuration").
                        WithError(err).
                        Error("failed to report RPC connection to StatsD")
        }
}

// reportIpv6Status sends to StatsD success true if suceessfuly read
// ipv6 label and false otherwise
func reportIpv6Status(
        infos map[string]interface{},
        logger logrus.FieldLogger,
) {
        if !reporters.HasReporters() {
                return
        }

        status := map[string]interface{}{
                reportersConstants.TagNodeHost: infos["host"].(string),
                reportersConstants.TagStatus:   "success",
        }

        if infos["metadata"] == nil ||
                infos["metadata"].(map[string]interface{})["ipv6Label"] == nil ||
                infos["metadata"].(map[string]interface{})["ipv6Label"].(string) == "" {
                status[reportersConstants.TagStatus] = "failed"
        }

        reporterErr := reporters.Report(reportersConstants.EventNodeIpv6Status, status)
        if reporterErr != nil {
                logger.
                        WithField("operation", "reportIpv6Status").
                        WithError(reporterErr).
                        Error("failed to report Ipv6 read status to StatsD")
        }
}

//Hostname returns the host name.
//If running on Kubernetes, returns the pod name.
func Hostname() string {
        hostname, _ := os.Hostname()
        return hostname
}

func toSecondsString(secs time.Duration) string {
        return fmt.Sprint(
                secs.Seconds(),
        )
}

1	package eventforwarder
2
3	import (
4	"context"
5	"fmt"
6	"os"
7	"strings"
8	"time"
9
10	"github.com/sirupsen/logrus"
11	pginterfaces "github.com/topfreegames/extensions/pg/interfaces"
12	redisinterfaces "github.com/topfreegames/extensions/redis/interfaces"
13	"github.com/topfreegames/maestro/models"
14	"github.com/topfreegames/maestro/reporters"
15	reportersConstants "github.com/topfreegames/maestro/reporters/constants"
16	"k8s.io/client-go/kubernetes"
17	)
18
19	// Response is the struct that defines a forwarder response
20	type Response struct {
21	Code int
22	Message string
23	}
24
25	// Forwarder is the struct that defines a forwarder with its EventForwarder as configured
26	// in maestro and the metadata configured for each scheduler
27	type Forwarder struct {
28	Func EventForwarder
29	Metadata map[string]interface{}
30	}
31
32	func getEnabledForwarders(
33	schedulerForwarders map[string]map[string]*models.Forwarder,
34	configuredForwarders []*Info,
35	) []*Forwarder {	7✔
36	enabledForwarders := make([]*Forwarder, 0)	7✔
37	for _, configuredFwdInfo := range configuredForwarders {	14✔
38	if schedulerFwds, ok := schedulerForwarders[configuredFwdInfo.Plugin]; ok {	14✔
39	if fwd, ok := schedulerFwds[configuredFwdInfo.Name]; ok {	14✔
40	if fwd.Enabled {	14✔
41	enabledForwarders = append(	7✔
42	enabledForwarders,	7✔
43	&Forwarder{configuredFwdInfo.Forwarder, fwd.Metadata},	7✔
44	)	7✔
45	}	7✔
46	}
47	}
48	}
49	return enabledForwarders	7✔
50	}
51
52	// ForwardRoomEvent forwards room event to app eventforwarders
53	func ForwardRoomEvent(
54	ctx context.Context,
55	forwarders []*Info,
56	redis redisinterfaces.RedisClient,
57	db pginterfaces.DB,
58	kubernetesClient kubernetes.Interface,
59	mr *models.MixedMetricsReporter,
60	room *models.Room,
61	status string,
62	eventType string,
63	metadata map[string]interface{},
64	schedulerCache *models.SchedulerCache,
65	logger logrus.FieldLogger,
66	addrGetter models.AddrGetter,
67	) (res *Response, err error) {	6✔
68	var eventWasForwarded bool	6✔
69	startTime := time.Now()	6✔
70	defer func() {	12✔
71	reportRPCStatus(	6✔
72	eventWasForwarded,	6✔
73	room.SchedulerName, RouteRoomEvent,	6✔
74	db,	6✔
75	schedulerCache,	6✔
76	logger,	6✔
77	err,	6✔
78	time.Now().Sub(startTime),	6✔
79	)	6✔
80	}()	6✔
81
82	l := logger.WithFields(logrus.Fields{	6✔
83	"op": "forwardRoomEvent",	6✔
84	"scheduler": room.SchedulerName,	6✔
85	"roomId": room.ID,	6✔
86	})	6✔
87		6✔
88	if len(metadata) == 0 {	12✔
89	metadata = map[string]interface{}{}	6✔
90	}	6✔
91
92	if len(forwarders) > 0 {	12✔
93	l.Debug("forwarding information to app forwarders")	6✔
94		6✔
95	cachedScheduler, err := schedulerCache.LoadScheduler(db, room.SchedulerName, true)	6✔
96	if err != nil {	6✔
97	l.WithError(err).Error("error reading scheduler from cache")	×
98	return nil, err	×
99	}	×
100
101	l.WithFields(logrus.Fields{	6✔
102	"schedulerForwarders": len(cachedScheduler.ConfigYAML.Forwarders),	6✔
103	}).Debug("checking enabled forwarders")	6✔
104		6✔
105	if len(cachedScheduler.ConfigYAML.Forwarders) > 0 {	11✔
106	enabledForwarders := getEnabledForwarders(cachedScheduler.ConfigYAML.Forwarders, forwarders)	5✔
107		5✔
108	l.WithFields(logrus.Fields{	5✔
109	"schedulerForwarders": len(cachedScheduler.ConfigYAML.Forwarders),	5✔
110	"enabledForwarders": len(enabledForwarders),	5✔
111	}).Debug("got enabled forwarders")	5✔
112		5✔
113	if len(enabledForwarders) > 0 {	10✔
114	infos := map[string]interface{}{	5✔
115	"roomId": room.ID,	5✔
116	"game": cachedScheduler.Scheduler.Game,	5✔
117	}	5✔
118	if eventType != PingTimeoutEvent && eventType != OccupiedTimeoutEvent {	8✔
119	infos, err = room.GetRoomInfos(redis, db, kubernetesClient, schedulerCache, cachedScheduler.Scheduler, addrGetter, mr)	3✔
120		3✔
121	if err != nil {	3✔
122	l.WithError(err).Error("error getting room info from redis")	×
123	return nil, err	×
124	}	×
125	reportIpv6Status(infos, logger)	3✔
126	} else { // fill host and port with zero values when pingTimeout or occupiedTimeout event so it won't break the GRPCForwarder	2✔
127	infos["host"] = ""	2✔
128	infos["port"] = int32(0)	2✔
129	}	2✔
130
131	if infos["metadata"] == nil {	7✔
132	infos["metadata"] = make(map[string]interface{}, len(metadata))	2✔
133	}	2✔
134
135	for key, info := range metadata {	5✔
136	infos["metadata"].(map[string]interface{})[key] = info	×
137	}	×
138	eventWasForwarded = true	5✔
139		5✔
140	return ForwardEventToForwarders(ctx, enabledForwarders, status, infos, l)	5✔
141	}
142	}
143	}
144
145	l.Debug("no forwarders configured and enabled")	1✔
146		1✔
147	return nil, nil	1✔
148	}
149
150	// ForwardPlayerEvent forwards player event to app eventforwarders
151	func ForwardPlayerEvent(
152	ctx context.Context,
153	forwarders []*Info,
154	db pginterfaces.DB,
155	kubernetesClient kubernetes.Interface,
156	room *models.Room,
157	event string,
158	metadata map[string]interface{},
159	schedulerCache *models.SchedulerCache,
160	logger logrus.FieldLogger,
161	) (resp *Response, err error) {	2✔
162	var eventWasForwarded bool	2✔
163	startTime := time.Now()	2✔
164	defer func() {	4✔
165	reportRPCStatus(	2✔
166	eventWasForwarded,	2✔
167	room.SchedulerName, RoutePlayerEvent,	2✔
168	db,	2✔
169	schedulerCache,	2✔
170	logger,	2✔
171	err,	2✔
172	time.Now().Sub(startTime),	2✔
173	)	2✔
174	}()	2✔
175
176	l := logger.WithFields(logrus.Fields{	2✔
177	"op": "forwardPlayerEvent",	2✔
178	"scheduler": room.SchedulerName,	2✔
179	"roomId": room.ID,	2✔
180	})	2✔
181	if len(forwarders) > 0 {	4✔
182	metadata["roomId"] = room.ID	2✔
183	cachedScheduler, err := schedulerCache.LoadScheduler(db, room.SchedulerName, true)	2✔
184	if err != nil {	2✔
185	return nil, err	×
186	}	×
187	metadata["game"] = cachedScheduler.Scheduler.Game	2✔
188	l.WithFields(logrus.Fields{	2✔
189	"schedulerForwarders": len(cachedScheduler.ConfigYAML.Forwarders),	2✔
190	}).Debug("checking enabled forwarders")	2✔
191	if len(cachedScheduler.ConfigYAML.Forwarders) > 0 {	4✔
192	enabledForwarders := getEnabledForwarders(cachedScheduler.ConfigYAML.Forwarders, forwarders)	2✔
193	l.WithFields(logrus.Fields{	2✔
194	"schedulerForwarders": len(cachedScheduler.ConfigYAML.Forwarders),	2✔
195	"enabledForwarders": len(enabledForwarders),	2✔
196	}).Debug("got enabled forwarders")	2✔
197	if len(enabledForwarders) > 0 {	4✔
198	eventWasForwarded = true	2✔
199	return ForwardEventToForwarders(ctx, enabledForwarders, event, metadata, l)	2✔
200	}	2✔
201	}
202	}
203	l.Debug("no forwarders configured and enabled")	×
204	return nil, nil	×
205	}
206
207	// ForwardEventToForwarders forwards
208	func ForwardEventToForwarders(
209	ctx context.Context,
210	forwarders []*Forwarder,
211	event string,
212	infos map[string]interface{},
213	logger logrus.FieldLogger,
214	) (*Response, error) {	7✔
215	logger.WithFields(logrus.Fields{	7✔
216	"forwarders": len(forwarders),	7✔
217	"infos": infos,	7✔
218	"event": event,	7✔
219	}).Debug("forwarding events")	7✔
220	respCode := 0	7✔
221	respMessage := []string{}	7✔
222	for _, f := range forwarders {	14✔
223	code, message, err := f.Func.Forward(ctx, event, infos, f.Metadata)	7✔
224	if err != nil {	10✔
225	return nil, err	3✔
226	}	3✔
227	// return the highest code received
228	// if a forwarder returns 200 and another 500 we should return 500 to indicate the error
229	// TODO: consider configuring for each forwarder if its errors can be ignored
230	if int(code) > respCode {	7✔
231	respCode = int(code)	3✔
232	}	3✔
233	if message != "" {	7✔
234	respMessage = append(respMessage, message)	3✔
235	}	3✔
236	}
237	resp := &Response{	4✔
238	Code: respCode,	4✔
239	Message: strings.Join(respMessage, ";"),	4✔
240	}	4✔
241	return resp, nil	4✔
242	}
243
244	// reportRPCStatus sends to StatsD success true if err is null
245	// and false otherwise
246	func reportRPCStatus(
247	eventWasForwarded bool,
248	schedulerName, forwardRoute string,
249	db pginterfaces.DB,
250	cache *models.SchedulerCache,
251	logger logrus.FieldLogger,
252	eventForwarderErr error,
253	responseTime time.Duration,
254	) {	8✔
255	if !reporters.HasReporters() {	9✔
256	return	1✔
257	}	1✔
258	log := logger.WithField("operation", "reportRPCStatus")	7✔
259		7✔
260	if !eventWasForwarded {	8✔
261	log.Debug("no rpc was made, returning...")	1✔
262	return	1✔
263	}	1✔
264
265	scheduler, err := cache.LoadScheduler(db, schedulerName, true)	6✔
266	if err != nil {	6✔
267	logger.	×
268	WithField("operation", "reportRPCStatus").	×
269	WithError(err).	×
270	Error("failed to report RPC connection to StatsD")	×
271	return	×
272	}	×
273
274	game := scheduler.ConfigYAML.Game	6✔
275		6✔
276	status := map[string]interface{}{	6✔
277	reportersConstants.TagGame: game,	6✔
278	reportersConstants.TagScheduler: schedulerName,	6✔
279	reportersConstants.TagHostname: Hostname(),	6✔
280	reportersConstants.TagRoute: forwardRoute,	6✔
281	reportersConstants.TagStatus: "success",	6✔
282	}	6✔
283		6✔
284	if eventForwarderErr != nil {	8✔
285	status[reportersConstants.TagStatus] = "failed"	2✔
286	status[reportersConstants.TagReason] = eventForwarderErr.Error()	2✔
287	}	2✔
288
289	reporterErr := reporters.Report(reportersConstants.EventRPCStatus, status)	6✔
290	if reporterErr != nil {	6✔
291	logger.	×
292	WithField("operation", "reportRPCStatus").	×
293	WithError(err).	×
294	Error("failed to report RPC connection to StatsD")	×
295	}	×
296
297	status[reportersConstants.TagResponseTime] = responseTime.String()	6✔
298	reporterErr = reporters.Report(reportersConstants.EventRPCDuration, status)	6✔
299	if reporterErr != nil {	6✔
300	logger.	×
301	WithField("operation", "reportRPCDuration").	×
302	WithError(err).	×
303	Error("failed to report RPC connection to StatsD")	×
304	}	×
305	}
306
307	// reportIpv6Status sends to StatsD success true if suceessfuly read
308	// ipv6 label and false otherwise
309	func reportIpv6Status(
310	infos map[string]interface{},
311	logger logrus.FieldLogger,
312	) {	3✔
313	if !reporters.HasReporters() {	4✔
314	return	1✔
315	}	1✔
316
317	status := map[string]interface{}{	2✔
318	reportersConstants.TagNodeHost: infos["host"].(string),	2✔
319	reportersConstants.TagStatus: "success",	2✔
320	}	2✔
321		2✔
322	if infos["metadata"] == nil \|\|	2✔
323	infos["metadata"].(map[string]interface{})["ipv6Label"] == nil \|\|	2✔
324	infos["metadata"].(map[string]interface{})["ipv6Label"].(string) == "" {	3✔
325	status[reportersConstants.TagStatus] = "failed"	1✔
326	}	1✔
327
328	reporterErr := reporters.Report(reportersConstants.EventNodeIpv6Status, status)	2✔
329	if reporterErr != nil {	2✔
330	logger.	×
331	WithField("operation", "reportIpv6Status").	×
332	WithError(reporterErr).	×
333	Error("failed to report Ipv6 read status to StatsD")	×
334	}	×
335	}
336
337	//Hostname returns the host name.
338	//If running on Kubernetes, returns the pod name.
339	func Hostname() string {	12✔
340	hostname, _ := os.Hostname()	12✔
341	return hostname	12✔
342	}	12✔
343
344	func toSecondsString(secs time.Duration) string {	×
345	return fmt.Sprint(	×
346	secs.Seconds(),	×
347	)	×
348	}	×

topfreegames / maestro / 1397

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous