DevOpsGOServer

1
package main
2

3
import (
4
	"context"
5
	"encoding/json"
6
	"errors"
7
	"log"
8
	"net/http"
9
	"strings"
10

11
	"github.com/go-kit/kit/endpoint"
12
)
13

14
type StringService interface {
15
	Uppercase(string) (string, error)
16
	Count(string) int
17
}
18

19
type Service interface {
20
	Uppercase(ctx context.Context, s string) (string, error)
21
	Count(ctx context.Context, s string) int
22
}
23

24
type stringService struct{}
25

26
func (stringService) Uppercase(s string) (string, error) {
27
	if s == "" {
28
		return "", ErrEmpty
29
	}
30
	return strings.ToUpper(s), nil
31
	
32
}
33

34
func (stringService) Count(s string) int {
35
	return len(s)
36
}
37

38
var ErrEmpty = errors.New("empty string")
39

40
var _ StringService = (*stringService)(nil) // compile-time interface check for StringService implementation
41

42
type uppercaseRequest struct {
43
	S string `json:"s"`
44
}
45

46
type uppercaseResponse struct {
47
	V   string `json:"v"`
48
	Err string `json:"err,omitempty"`
49

50
}
51

52
type uppercaseResponse struct {
53
	V   string `json:"v"`
54
	Err string `json:"err,omitempty"`
55
}
56

57
type countRequest struct {
58
	S string `json:"s"`
59
}
60

61
type countResponse struct {
62
	V int `json:"v"`
63
}
64

65
func countScore(scores []int) int {
66
	total := 0
67
	for _, score := range scores {
68
		total += score
69
	}
70
	return total
71
}
72

73
func makeUppercaseEndpoint(svc StringService) endpoint.Endpoint {
74
	return func(_ context.Context, request interface{}) (interface{}, error) {
75
		req := request.(uppercaseRequest)
76
		v, err := svc.Uppercase(req.S)
77
		if err != nil {
78
			return uppercaseResponse{v, err.Error()}, nil
79
		}
80

81
		resp := uppercaseResponse{v, ""}
82
		log.Println("Request: ", req.S, ", Response: ", resp.V)
83
		return resp, nil
84
	}
85
}
86

87
func makeCountEndpoint(svc StringService) endpoint.Endpoint {
88
	return func(_ context.Context, request interface{}) (interface{}, error) {
89
		req := request.(countRequest)
90
		v := svc.Count(req.S)
91
		
92
		resp := countResponse{v}
93
		log.Println("Request: ", req.S, ", Response: ", resp.V)
94
		return resp, nil
95
	}
96
}
97

98
func decodeUppercaseRequest(_ context.Context, r *http.Request) (interface{}, error) {
99
	var request uppercaseRequest
100
	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
101
		return nil, err
102
	}
103
	return request, nil
104
}
105

106
func decodeUppercaseResponse(_ context.Context, r *http.Request) (interface{}, error) {
107
	var response uppercaseResponse
108
	if err := json.NewDecoder(r.Body).Decode(&response); err != nil {
109
		return nil, err
110
	}
111
	return response, nil
112

113
}
114

115
func decodeCountRequest(_ context.Context, r *http.Request) (interface{}, error) {
116
	var request countRequest
117
	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
118
		return nil, err
119
	}
120
	return request, nil
121

122
}
123

124
func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
125
	return json.NewEncoder(w).Encode(response)
126

127
}
128

129
func decodeCountRequest(_ context.Context, r *http.Request) (interface{}, error) {
130
	var request countRequest
131
	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
132
		return nil, err
133
	}
134
	return request, nil
135
}
136

137
func decodeUppercaseRequest(_ context.Context, r *http.Request) (interface{}, error) {
138
	var request uppercaseRequest
139
	if err := json.NewDecoder(r.Body).Decode(&request); err != nil {
140
		return nil, err
141
	}
142
	return request, nil
143

144
}
145

146
func decodeUppercaseResponse(_ context.Context, r *http.Request) (interface{}, error) {
147
	var response uppercaseResponse
148
	if err := json.NewDecoder(r.Body).Decode(&response); err != nil {
149
		return nil, err
150
	}
151
	return response, nil
152

153
}
154

155
func encodeResponse(_ context.Context, w http.ResponseWriter, response interface{}) error {
156
	return json.NewEncoder(w).Encode(response)
157
}
158

159
func decodeCountResponse(_ context.Context, r *http.Request) (interface{}, error) {
160
	var response countResponse
161
	if err := json.NewDecoder(r.Body).Decode(&response); err != nil {
162
		return nil, err
163
	}
164
	return response, nil
165

166
}
167