30137012301

Committed 24 Jul 2026 11:40PM UTC coverage: 84.416% (-0.3%) from 84.738%

Build # 30137012301

Build Type

Pull #39

github

Committed by

et-nik

Commit Message

plugins rcon and query

Pull Request Pull Request #39: Plugins rcon and query

Coverage Stats

552 of 896 new or added lines in 18 files covered. (61.61%)

7 existing lines in 3 files now uncovered.

49400 of 58520 relevant lines covered (84.42%)

34214.27 hits per line

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

8.79

/pkg/plugin/wrapper_protocol.go

package plugin

import (
        "context"

        "github.com/gameap/gameap/pkg/plugin/sdk/protocol"
        "github.com/pkg/errors"
)

// The module wrapper also implements the optional ProtocolService (RCON/Query
// protocol extension). The methods share the same guest-call gate as the core
// PluginService, so calls into a plugin stay serialized across both services.
var _ protocol.ProtocolService = (*pluginServiceWrapper)(nil)

func (p *pluginServiceWrapper) GetRconProtocols(
        ctx context.Context,
        request *protocol.GetRconProtocolsRequest,
) (*protocol.GetRconProtocolsResponse, error) {
        if p.getrconprotocols == nil {
                return &protocol.GetRconProtocolsResponse{}, nil
        }

        bytes, err := p.callFunction(ctx, p.getrconprotocols, request)
        if err != nil {
                return nil, err
        }

        response := new(protocol.GetRconProtocolsResponse)
        if err = response.UnmarshalVT(bytes); err != nil {
                return nil, err
        }

        return response, nil
}

func (p *pluginServiceWrapper) GetQueryProtocols(
        ctx context.Context,
        request *protocol.GetQueryProtocolsRequest,
) (*protocol.GetQueryProtocolsResponse, error) {
        if p.getqueryprotocols == nil {
                return &protocol.GetQueryProtocolsResponse{}, nil
        }

        bytes, err := p.callFunction(ctx, p.getqueryprotocols, request)
        if err != nil {
                return nil, err
        }

        response := new(protocol.GetQueryProtocolsResponse)
        if err = response.UnmarshalVT(bytes); err != nil {
                return nil, err
        }

        return response, nil
}

func (p *pluginServiceWrapper) RconOpen(
        ctx context.Context,
        request *protocol.RconOpenRequest,
) (*protocol.RconOpenResponse, error) {
        if p.rconopen == nil {
                return nil, errors.WithMessage(ErrExportNotFound, "protocol_service_rcon_open")
        }

        bytes, err := p.callFunction(ctx, p.rconopen, request)
        if err != nil {
                return nil, err
        }

        response := new(protocol.RconOpenResponse)
        if err = response.UnmarshalVT(bytes); err != nil {
                return nil, err
        }

        return response, nil
}

func (p *pluginServiceWrapper) RconExecute(
        ctx context.Context,
        request *protocol.RconExecuteRequest,
) (*protocol.RconExecuteResponse, error) {
        if p.rconexecute == nil {
                return nil, errors.WithMessage(ErrExportNotFound, "protocol_service_rcon_execute")
        }

        bytes, err := p.callFunction(ctx, p.rconexecute, request)
        if err != nil {
                return nil, err
        }

        response := new(protocol.RconExecuteResponse)
        if err = response.UnmarshalVT(bytes); err != nil {
                return nil, err
        }

        return response, nil
}

func (p *pluginServiceWrapper) RconClose(
        ctx context.Context,
        request *protocol.RconCloseRequest,
) (*protocol.RconCloseResponse, error) {
        if p.rconclose == nil {
                return nil, errors.WithMessage(ErrExportNotFound, "protocol_service_rcon_close")
        }

        bytes, err := p.callFunction(ctx, p.rconclose, request)
        if err != nil {
                return nil, err
        }

        response := new(protocol.RconCloseResponse)
        if err = response.UnmarshalVT(bytes); err != nil {
                return nil, err
        }

        return response, nil
}

func (p *pluginServiceWrapper) QueryServer(
        ctx context.Context,
        request *protocol.QueryServerRequest,
) (*protocol.QueryServerResponse, error) {
        if p.queryserver == nil {
                return nil, errors.WithMessage(ErrExportNotFound, "protocol_service_query_server")
        }

        bytes, err := p.callFunction(ctx, p.queryserver, request)
        if err != nil {
                return nil, err
        }

        response := new(protocol.QueryServerResponse)
        if err = response.UnmarshalVT(bytes); err != nil {
                return nil, err
        }

        return response, nil
}

func (p *pluginServiceWrapper) ParsePlayers(
        ctx context.Context,
        request *protocol.ParsePlayersRequest,
) (*protocol.ParsePlayersResponse, error) {
        if p.parseplayers == nil {
                return nil, errors.WithMessage(ErrExportNotFound, "protocol_service_parse_players")
        }

        bytes, err := p.callFunction(ctx, p.parseplayers, request)
        if err != nil {
                return nil, err
        }

        response := new(protocol.ParsePlayersResponse)
        if err = response.UnmarshalVT(bytes); err != nil {
                return nil, err
        }

        return response, nil
}

1	package plugin
2
3	import (
4	"context"
5
6	"github.com/gameap/gameap/pkg/plugin/sdk/protocol"
7	"github.com/pkg/errors"
8	)
9
10	// The module wrapper also implements the optional ProtocolService (RCON/Query
11	// protocol extension). The methods share the same guest-call gate as the core
12	// PluginService, so calls into a plugin stay serialized across both services.
13	var _ protocol.ProtocolService = (*pluginServiceWrapper)(nil)
14
15	func (p *pluginServiceWrapper) GetRconProtocols(
16	ctx context.Context,
17	request *protocol.GetRconProtocolsRequest,
18	) (*protocol.GetRconProtocolsResponse, error) {	3✔
19	if p.getrconprotocols == nil {	6✔
20	return &protocol.GetRconProtocolsResponse{}, nil	3✔
21	}	3✔
22
NEW 23	bytes, err := p.callFunction(ctx, p.getrconprotocols, request)	×
NEW 24	if err != nil {	×
NEW 25	return nil, err	×
NEW 26	}	×
27
NEW 28	response := new(protocol.GetRconProtocolsResponse)	×
NEW 29	if err = response.UnmarshalVT(bytes); err != nil {	×
NEW 30	return nil, err	×
NEW 31	}	×
32
NEW 33	return response, nil	×
34	}
35
36	func (p *pluginServiceWrapper) GetQueryProtocols(
37	ctx context.Context,
38	request *protocol.GetQueryProtocolsRequest,
39	) (*protocol.GetQueryProtocolsResponse, error) {	3✔
40	if p.getqueryprotocols == nil {	6✔
41	return &protocol.GetQueryProtocolsResponse{}, nil	3✔
42	}	3✔
43
NEW 44	bytes, err := p.callFunction(ctx, p.getqueryprotocols, request)	×
NEW 45	if err != nil {	×
NEW 46	return nil, err	×
NEW 47	}	×
48
NEW 49	response := new(protocol.GetQueryProtocolsResponse)	×
NEW 50	if err = response.UnmarshalVT(bytes); err != nil {	×
NEW 51	return nil, err	×
NEW 52	}	×
53
NEW 54	return response, nil	×
55	}
56
57	func (p *pluginServiceWrapper) RconOpen(
58	ctx context.Context,
59	request *protocol.RconOpenRequest,
NEW 60	) (*protocol.RconOpenResponse, error) {	×
NEW 61	if p.rconopen == nil {	×
NEW 62	return nil, errors.WithMessage(ErrExportNotFound, "protocol_service_rcon_open")	×
NEW 63	}	×
64
NEW 65	bytes, err := p.callFunction(ctx, p.rconopen, request)	×
NEW 66	if err != nil {	×
NEW 67	return nil, err	×
NEW 68	}	×
69
NEW 70	response := new(protocol.RconOpenResponse)	×
NEW 71	if err = response.UnmarshalVT(bytes); err != nil {	×
NEW 72	return nil, err	×
NEW 73	}	×
74
NEW 75	return response, nil	×
76	}
77
78	func (p *pluginServiceWrapper) RconExecute(
79	ctx context.Context,
80	request *protocol.RconExecuteRequest,
NEW 81	) (*protocol.RconExecuteResponse, error) {	×
NEW 82	if p.rconexecute == nil {	×
NEW 83	return nil, errors.WithMessage(ErrExportNotFound, "protocol_service_rcon_execute")	×
NEW 84	}	×
85
NEW 86	bytes, err := p.callFunction(ctx, p.rconexecute, request)	×
NEW 87	if err != nil {	×
NEW 88	return nil, err	×
NEW 89	}	×
90
NEW 91	response := new(protocol.RconExecuteResponse)	×
NEW 92	if err = response.UnmarshalVT(bytes); err != nil {	×
NEW 93	return nil, err	×
NEW 94	}	×
95
NEW 96	return response, nil	×
97	}
98
99	func (p *pluginServiceWrapper) RconClose(
100	ctx context.Context,
101	request *protocol.RconCloseRequest,
NEW 102	) (*protocol.RconCloseResponse, error) {	×
NEW 103	if p.rconclose == nil {	×
NEW 104	return nil, errors.WithMessage(ErrExportNotFound, "protocol_service_rcon_close")	×
NEW 105	}	×
106
NEW 107	bytes, err := p.callFunction(ctx, p.rconclose, request)	×
NEW 108	if err != nil {	×
NEW 109	return nil, err	×
NEW 110	}	×
111
NEW 112	response := new(protocol.RconCloseResponse)	×
NEW 113	if err = response.UnmarshalVT(bytes); err != nil {	×
NEW 114	return nil, err	×
NEW 115	}	×
116
NEW 117	return response, nil	×
118	}
119
120	func (p *pluginServiceWrapper) QueryServer(
121	ctx context.Context,
122	request *protocol.QueryServerRequest,
NEW 123	) (*protocol.QueryServerResponse, error) {	×
NEW 124	if p.queryserver == nil {	×
NEW 125	return nil, errors.WithMessage(ErrExportNotFound, "protocol_service_query_server")	×
NEW 126	}	×
127
NEW 128	bytes, err := p.callFunction(ctx, p.queryserver, request)	×
NEW 129	if err != nil {	×
NEW 130	return nil, err	×
NEW 131	}	×
132
NEW 133	response := new(protocol.QueryServerResponse)	×
NEW 134	if err = response.UnmarshalVT(bytes); err != nil {	×
NEW 135	return nil, err	×
NEW 136	}	×
137
NEW 138	return response, nil	×
139	}
140
141	func (p *pluginServiceWrapper) ParsePlayers(
142	ctx context.Context,
143	request *protocol.ParsePlayersRequest,
NEW 144	) (*protocol.ParsePlayersResponse, error) {	×
NEW 145	if p.parseplayers == nil {	×
NEW 146	return nil, errors.WithMessage(ErrExportNotFound, "protocol_service_parse_players")	×
NEW 147	}	×
148
NEW 149	bytes, err := p.callFunction(ctx, p.parseplayers, request)	×
NEW 150	if err != nil {	×
NEW 151	return nil, err	×
NEW 152	}	×
153
NEW 154	response := new(protocol.ParsePlayersResponse)	×
NEW 155	if err = response.UnmarshalVT(bytes); err != nil {	×
NEW 156	return nil, err	×
NEW 157	}	×
158
NEW 159	return response, nil	×
160	}

gameap / gameap / 30137012301

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