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(&registration); 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",