Example #1
0
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.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)
}
Example #2
0
func registryCommands() []cli.Command {
	return []cli.Command{
		{
			Name:  "list",
			Usage: "List items in registry",
			Subcommands: []cli.Command{
				{
					Name:  "services",
					Usage: "List services in registry",
					Action: func(c *cli.Context) {
						rsp, err := registry.ListServices()
						if err != nil {
							fmt.Println(err.Error())
							return
						}
						for _, service := range rsp {
							fmt.Println(service.Name)
						}
					},
				},
			},
		},
		{
			Name:  "get",
			Usage: "Get item from registry",
			Subcommands: []cli.Command{
				{
					Name:  "service",
					Usage: "Get service from registry",
					Action: func(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
						}
						fmt.Printf("%s\n\n", service.Name)
						fmt.Println("Id\tAddress\tPort\tMetadata")
						for _, node := range service.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, ","))
						}
					},
				},
			},
		},
	}
}
Example #3
0
func (s *Sidecar) serve() {
	http.HandleFunc("/health", func(w http.ResponseWriter, r *http.Request) {
		if c, err := s.hc(); err != nil {
			http.Error(w, err.Error(), c)
			return
		}
	})

	http.HandleFunc("/registry", func(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 {
			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)
	})

	http.HandleFunc("/rpc", rpcHandler)

	http.HandleFunc("/broker", brokerHandler)

	if err := http.ListenAndServe(Address, nil); err != nil {
		log.Fatal(err)
		os.Exit(1)
	}
}
Example #4
0
File: web.go Project: cxxly/micro
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
		}

		t, err := template.New("service").Funcs(template.FuncMap{
			"format": format,
		}).Parse(serviceTemplate)
		if err != nil {
			http.Error(w, "Error occurred:"+err.Error(), 500)
			return
		}

		if err := t.ExecuteTemplate(w, "T", s); err != nil {
			http.Error(w, "Error occurred:"+err.Error(), 500)
			return
		}
		return
	}

	services, err := registry.ListServices()
	if err != nil {
		http.Error(w, "Error occurred:"+err.Error(), 500)
		return
	}

	t, err := template.New("registry").Parse(registryTemplate)
	if err != nil {
		http.Error(w, "Error occurred:"+err.Error(), 500)
		return
	}

	if err := t.ExecuteTemplate(w, "T", services); err != nil {
		http.Error(w, "Error occurred:"+err.Error(), 500)
		return
	}
}
Example #5
0
func (r *rpcClient) Stream(ctx context.Context, request Request, responseChan interface{}) (Streamer, error) {
	service, err := registry.GetService(request.Service())
	if err != nil {
		return nil, errors.InternalServerError("go.micro.client", err.Error())
	}

	if len(service.Nodes) == 0 {
		return nil, errors.NotFound("go.micro.client", "Service not found")
	}

	n := rand.Int() % len(service.Nodes)
	node := service.Nodes[n]

	address := node.Address
	if node.Port > 0 {
		address = fmt.Sprintf("%s:%d", address, node.Port)
	}

	return r.stream(ctx, address, request, responseChan)
}
Example #6
0
func (h *httpBroker) Publish(topic string, msg *Message) 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
	}

	for _, node := range s.Nodes {
		r, err := http.Post(fmt.Sprintf("http://%s:%d%s", node.Address, node.Port, DefaultSubPath), "application/json", bytes.NewBuffer(b))
		if err == nil {
			r.Body.Close()
		}
	}

	return nil
}
Example #7
0
func registryCommands() []cli.Command {
	return []cli.Command{
		{
			Name:  "list",
			Usage: "List items in registry",
			Subcommands: []cli.Command{
				{
					Name:  "services",
					Usage: "List services in registry",
					Action: func(c *cli.Context) {
						rsp, err := registry.ListServices()
						if err != nil {
							fmt.Println(err.Error())
							return
						}
						for _, service := range rsp {
							fmt.Println(service.Name)
						}
					},
				},
			},
		},
		{
			Name:  "get",
			Usage: "Get item from registry",
			Subcommands: []cli.Command{
				{
					Name:  "service",
					Usage: "Get service from registry",
					Action: func(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
						}
						fmt.Printf("%s\n\n", service.Name)
						fmt.Println("Id\tAddress\tPort\tMetadata")
						for _, node := range service.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.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 = formatEndpoint(e.Request.Values[0], 0)
							} else {
								request = " {}"
							}
							if e.Response != nil && len(e.Response.Values) > 0 {
								response = formatEndpoint(e.Response.Values[0], 0)
							} else {
								response = " {}"
							}
							fmt.Printf("\nEndpoint: %s\nMetadata: %s\n", e.Name, strings.Join(meta, ","))
							fmt.Printf("Request:%s\nResponse:%s\n", request, response)
						}
					},
				},
			},
		},
	}
}
Example #8
0
func Commands() []cli.Command {
	commands := []cli.Command{
		{
			Name:        "registry",
			Usage:       "Query registry",
			Subcommands: registryCommands(),
		},
		{
			Name:  "query",
			Usage: "Query a service method using rpc",
			Action: func(c *cli.Context) {
				if len(c.Args()) < 2 {
					fmt.Println("require service and method")
					return
				}
				service := c.Args()[0]
				method := c.Args()[1]
				var request map[string]interface{}
				var response map[string]interface{}
				json.Unmarshal([]byte(strings.Join(c.Args()[2:], " ")), &request)
				req := client.NewJsonRequest(service, method, request)
				err := client.Call(context.Background(), req, &response)
				if err != nil {
					fmt.Printf("error calling %s.%s: %v\n", service, method, err)
					return
				}
				b, _ := json.MarshalIndent(response, "", "\t")
				fmt.Println(string(b))
			},
		},
		{
			Name:  "health",
			Usage: "Query the health of a service",
			Action: func(c *cli.Context) {
				if !c.Args().Present() {
					fmt.Println("require service name")
					return
				}
				service, err := registry.GetService(c.Args().First())
				if err != nil {
					fmt.Printf("error querying registry: %v", err)
					return
				}
				fmt.Println("node\t\taddress:port\t\tstatus")
				req := client.NewRequest(service.Name, "Debug.Health", &health.Request{})
				for _, node := range service.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)
				}
			},
		},
	}

	return append(commands, registryCommands()...)
}