func resourceConsulServiceCreate(d *schema.ResourceData, meta interface{}) error {
client := meta.(*consulapi.Client)
agent := client.Agent()
name := d.Get("name").(string)
identifier := name
if serviceId, ok := d.GetOk("service_id"); ok {
identifier = serviceId.(string)
}
registration := consulapi.AgentServiceRegistration{Name: name, ID: identifier}
if address, ok := d.GetOk("address"); ok {
registration.Address = address.(string)
}
if port, ok := d.GetOk("port"); ok {
registration.Port = port.(int)
}
if v, ok := d.GetOk("tags"); ok {
vs := v.([]interface{})
s := make([]string, len(vs))
for i, raw := range vs {
s[i] = raw.(string)
}
registration.Tags = s
}
if err := agent.ServiceRegister(®istration); err != nil {
return fmt.Errorf("Failed to register service '%s' with Consul agent: %v", name, err)
}
// Update the resource
if serviceMap, err := agent.Services(); err != nil {
return fmt.Errorf("Failed to read services from Consul agent: %v", err)
} else if service, ok := serviceMap[identifier]; !ok {
return fmt.Errorf("Failed to read service '%s' from Consul agent: %v", identifier, err)
} else {
d.SetId(service.ID)
d.Set("address", service.Address)
d.Set("service_id", service.ID)
d.Set("name", service.Service)
d.Set("port", service.Port)
tags := make([]string, 0, len(service.Tags))
for _, tag := range service.Tags {
tags = append(tags, tag)
}
d.Set("tags", tags)
}
return nil
}
func register() {
registration := new(consulApi.AgentServiceRegistration)
registration.ID = serviceId
registration.Name = serviceName
registration.Port, _ = strconv.Atoi(servicePort)
registration.Tags = serviceTags
registration.Address = serviceIp
// TODO build Check latter
log.Println("ID is: ", registration.ID)
log.Println("Name is: ", registration.Name)
log.Println("Port is: ", registration.Port)
log.Println("Tags is: ", registration.Tags)
log.Println("Address is: ", registration.Address)
consulClient.Agent().ServiceRegister(registration)
}
func (r *ConsulAdapter) Register(service *bridge.Service) error {
registration := new(consulapi.AgentServiceRegistration)
registration.ID = service.ID
registration.Name = service.Name
registration.Port = service.Port
registration.Tags = service.Tags
registration.Address = service.IP
registration.Check = r.buildCheck(service)
if r.servicePrefix != "" {
kv := r.client.KV()
addr := service.IP + ":" + strconv.Itoa(service.Port)
host_path := r.servicePrefix + "/" + "nodes/" + service.ID + "/"
service_path := r.servicePrefix + "/" + "services/" + service.Name + "/" + service.ID + "/"
_, err := kv.Put(&consulapi.KVPair{Key: host_path + "URI", Value: []byte(addr)}, nil)
if err != nil {
return (err)
}
_, err = kv.Put(&consulapi.KVPair{Key: service_path + "URI", Value: []byte(addr)}, nil)
if err != nil {
return (err)
}
for k, v := range service.Attrs {
_, err := kv.Put(&consulapi.KVPair{Key: host_path + k, Value: []byte(v)}, nil)
if err != nil {
return (err)
}
_, err = kv.Put(&consulapi.KVPair{Key: service_path + k, Value: []byte(v)}, nil)
if err != nil {
return (err)
}
}
}
return r.client.Agent().ServiceRegister(registration)
}
func doConsulAddService(agent *consulapi.Agent, ConsulName string, address string) (*consulapi.AgentService, error) {
registration := new(consulapi.AgentServiceRegistration)
registration.Name = ConsulName
registration.Port = 80
registration.Address = address
err := agent.ServiceRegister(registration)
if err != nil {
return nil, err
}
svcs, err := agent.Services()
if err != nil {
return nil, err
}
svc, found := svcs[registration.Name]
if !found {
return nil, errors.New("Could not find service " + registration.Name + " after registration!")
}
return svc, nil
}
// createService creates a Consul AgentService from a Nomad ConsulService.
func (c *Syncer) createService(service *structs.Service, domain ServiceDomain, key ServiceKey) (*consul.AgentServiceRegistration, error) {
c.registryLock.RLock()
defer c.registryLock.RUnlock()
srv := consul.AgentServiceRegistration{
ID: string(generateConsulServiceID(domain, key)),
Name: service.Name,
Tags: service.Tags,
}
host, port := c.addrFinder(service.PortLabel)
if host != "" {
srv.Address = host
}
if port != 0 {
srv.Port = port
}
return &srv, nil
}
func (r *ConsulAdapter) Register(service *bridge.Service) error {
registration := new(consulapi.AgentServiceRegistration)
registration.ID = service.ID
registration.Name = service.Name
registration.Port = service.Port
registration.Tags = service.Tags
registration.Address = service.IP
registration.Checks = r.buildChecks(service)
return r.client.Agent().ServiceRegister(registration)
}
func SetService(c *cli.Context) {
// Get client
cfg, err := NewAppConfig(c)
if err != nil {
log.Errorf("Failed to get client: %v", err)
return
}
reg := new(api.AgentServiceRegistration)
for _, arg := range append(c.Args().Tail(), c.Args().First()) {
split := strings.SplitN(arg, "=", 2)
switch strings.ToLower(split[0]) {
case "address":
reg.Address = split[1]
case "name":
reg.Name = split[1]
case "id":
reg.ID = split[1]
case "port":
port, _ := strconv.ParseInt(split[1], 10, 32)
reg.Port = int(port)
case "tags":
tags := strings.Split(split[1], ",")
reg.Tags = tags
}
}
err = cfg.client.Agent().ServiceRegister(reg)
if err != nil {
log.Errorf("%v\n", err)
return
}
log.Println("Success")
}
// the types are so close yet SO DIFFERENT
func updateConsulTags(agent *consulapi.Agent, svc *consulapi.AgentService) error {
registration := new(consulapi.AgentServiceRegistration)
registration.Name = svc.Service
registration.ID = svc.ID
registration.Tags = svc.Tags
registration.Port = svc.Port
registration.Address = svc.Address
return agent.ServiceRegister(registration)
}
func (r *ConsulAdapter) Register(service *bridge.Service) error {
registration := new(consulapi.AgentServiceRegistration)
registration.ID = service.ID
registration.Name = service.Name
registration.Port = service.Port
registration.Tags = service.Tags
registration.Address = service.IP
registration.Check = r.buildCheck(service)
if r.servicePrefix != "" {
kv := r.client.KV()
for k, v := range service.Attrs {
pair := &consulapi.KVPair{Key: r.servicePrefix + "/" + service.ID + "/" + k, Value: []byte(v)}
_, err := kv.Put(pair, nil)
if err != nil {
panic(err)
}
}
}
return r.client.Agent().ServiceRegister(registration)
}
func (r *Adapter) Register(group *types.ServiceGroup) error {
for _, service := range group.Services {
if r.dryRun {
log.WithFields(log.Fields{
"prefix": "consul",
"ip": group.IP,
"id": service.ID,
"name": service.Name,
"port": service.ExposedPort,
}).Info("[dry-run] Would register service")
continue
}
log.WithFields(log.Fields{
"prefix": "consul",
"ip": group.IP,
"id": service.ID,
"name": service.Name,
"port": service.ExposedPort,
}).Info("Registering service")
registration := new(consulAPI.AgentServiceRegistration)
registration.Address = group.IP
registration.ID = service.ID
registration.Name = service.Name
registration.Tags = service.Tags
registration.Port = service.ExposedPort
err := r.client.Agent().ServiceRegister(registration)
if err != nil {
return err
}
}
return nil
}
"github.com/tedsuo/ifrit/ginkgomon"
. "github.com/onsi/ginkgo"
. "github.com/onsi/gomega"
)
var _ = Describe("Service Registration Integration", func() {
const (
serviceID = "test-id"
serviceName = "Test-Service"
)
var (
consulClient consuladapter.Client
logger lager.Logger
clock *fakeclock.FakeClock
registration *api.AgentServiceRegistration
registrationProcess ifrit.Process
)
BeforeEach(func() {
consulClient = consulRunner.NewClient()
logger = lagertest.NewTestLogger("test")
clock = fakeclock.NewFakeClock(time.Now())
registration = &api.AgentServiceRegistration{
ID: serviceID,
Name: serviceName,
Tags: []string{"a", "b", "c"},
Port: 8080,
Address: "127.0.0.1",