func getService(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
service := r.Form.Get("service")
if len(service) == 0 {
http.Error(w, "Require service", 400)
return
}
s, err := registry.GetService(service)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
if s == nil || len(s) == 0 || len(s[0].Name) == 0 {
http.Error(w, "Service not found", 404)
return
}
b, err := json.Marshal(s)
if err != nil {
http.Error(w, err.Error(), 500)
return
}
w.Header().Set("Content-Type", "application/json")
w.Header().Set("Content-Length", strconv.Itoa(len(b)))
w.Write(b)
}
func getService(c *cli.Context) {
if !c.Args().Present() {
fmt.Println("Service required")
return
}
service, err := registry.GetService(c.Args().First())
if err != nil {
fmt.Println(err.Error())
return
}
if len(service) == 0 {
fmt.Println("Service not found")
return
}
fmt.Printf("service %s\n", service[0].Name)
for _, serv := range service {
fmt.Println("\nversion ", serv.Version)
fmt.Println("\nId\tAddress\tPort\tMetadata")
for _, node := range serv.Nodes {
var meta []string
for k, v := range node.Metadata {
meta = append(meta, k+"="+v)
}
fmt.Printf("%s\t%s\t%d\t%s\n", node.Id, node.Address, node.Port, strings.Join(meta, ","))
}
}
for _, e := range service[0].Endpoints {
var request, response string
var meta []string
for k, v := range e.Metadata {
meta = append(meta, k+"="+v)
}
if e.Request != nil && len(e.Request.Values) > 0 {
request = "{\n"
for _, v := range e.Request.Values {
request += formatEndpoint(v, 0)
}
request += "}"
} else {
request = "{}"
}
if e.Response != nil && len(e.Response.Values) > 0 {
response = "{\n"
for _, v := range e.Response.Values {
response += formatEndpoint(v, 0)
}
response += "}"
} else {
response = "{}"
}
fmt.Printf("\nEndpoint: %s\nMetadata: %s\n", e.Name, strings.Join(meta, ","))
fmt.Printf("Request: %s\n\nResponse: %s\n", request, response)
}
}
func (h *httpBroker) Publish(topic string, msg *Message, opts ...PublishOption) error {
s, err := registry.GetService("topic:" + topic)
if err != nil {
return err
}
msg.Header[":topic"] = topic
b, err := json.Marshal(msg)
if err != nil {
return err
}
fn := func(node *registry.Node, b io.Reader) {
scheme := "http"
// check if secure is added in metadata
if node.Metadata["secure"] == "true" {
scheme = "https"
}
vals := url.Values{}
vals.Add("id", node.Id)
uri := fmt.Sprintf("%s://%s:%d%s?%s", scheme, node.Address, node.Port, DefaultSubPath, vals.Encode())
r, err := h.c.Post(uri, "application/json", b)
if err == nil {
r.Body.Close()
}
}
buf := bytes.NewBuffer(nil)
for _, service := range s {
// broadcast version means broadcast to all nodes
if service.Version == broadcastVersion {
for _, node := range service.Nodes {
buf.Reset()
buf.Write(b)
fn(node, buf)
}
return nil
}
node := service.Nodes[rand.Int()%len(service.Nodes)]
buf.Reset()
buf.Write(b)
fn(node, buf)
return nil
}
buf.Reset()
buf = nil
return nil
}
func registryHandler(w http.ResponseWriter, r *http.Request) {
r.ParseForm()
svc := r.Form.Get("service")
if len(svc) > 0 {
s, err := registry.GetService(svc)
if err != nil {
http.Error(w, "Error occurred:"+err.Error(), 500)
return
}
if r.Header.Get("Content-Type") == "application/json" {
b, err := json.Marshal(map[string]interface{}{
"services": s,
})
if err != nil {
http.Error(w, "Error occurred:"+err.Error(), 500)
return
}
w.Header().Set("Content-Type", "application/json")
w.Write(b)
return
}
render(w, r, serviceTemplate, s)
return
}
services, err := registry.ListServices()
if err != nil {
http.Error(w, "Error occurred:"+err.Error(), 500)
return
}
if r.Header.Get("Content-Type") == "application/json" {
b, err := json.Marshal(map[string]interface{}{
"services": services,
})
if err != nil {
http.Error(w, "Error occurred:"+err.Error(), 500)
return
}
w.Header().Set("Content-Type", "application/json")
w.Write(b)
return
}
render(w, r, registryTemplate, services)
}
func queryHealth(c *cli.Context) {
if !c.Args().Present() {
fmt.Println("require service name")
return
}
service, err := registry.GetService(c.Args().First())
if err != nil {
fmt.Println(err.Error())
return
}
if service == nil || len(service) == 0 {
fmt.Println("Service not found")
return
}
req := client.NewRequest(service[0].Name, "Debug.Health", &health.Request{})
fmt.Printf("service %s\n\n", service[0].Name)
for _, serv := range service {
fmt.Println("\nversion ", serv.Version)
fmt.Println("\nnode\t\taddress:port\t\tstatus")
for _, node := range serv.Nodes {
address := node.Address
if node.Port > 0 {
address = fmt.Sprintf("%s:%d", address, node.Port)
}
rsp := &health.Response{}
err := client.CallRemote(context.Background(), address, req, rsp)
var status string
if err != nil {
status = err.Error()
} else {
status = rsp.Status
}
fmt.Printf("%s\t\t%s:%d\t\t%s\n", node.Id, node.Address, node.Port, status)
}
}
}