// AddHost register a host with serviced. Returns an error if host already
// exists or if the host's IP is a virtual IP
func (f *Facade) AddHost(ctx datastore.Context, entity *host.Host) error {
glog.V(2).Infof("Facade.AddHost: %v", entity)
exists, err := f.GetHost(ctx, entity.ID)
if err != nil {
return err
}
if exists != nil {
return fmt.Errorf("host already exists: %s", entity.ID)
}
// only allow hostid of master if SERVICED_REGISTRY is false
if !docker.UseRegistry() {
masterHostID, err := utils.HostID()
if err != nil {
return fmt.Errorf("unable to retrieve hostid %s: %s", entity.ID, err)
}
if entity.ID != masterHostID {
return fmt.Errorf("SERVICED_REGISTRY is false and hostid %s does not match master %s", entity.ID, masterHostID)
}
}
// validate Pool exists
pool, err := f.GetResourcePool(ctx, entity.PoolID)
if err != nil {
return fmt.Errorf("error verifying pool exists: %v", err)
}
if pool == nil {
return fmt.Errorf("error creating host, pool %s does not exists", entity.PoolID)
}
// verify that there are no virtual IPs with the given host IP(s)
for _, ip := range entity.IPs {
if exists, err := f.HasIP(ctx, pool.ID, ip.IPAddress); err != nil {
return fmt.Errorf("error verifying ip %s exists: %v", ip.IPAddress, err)
} else if exists {
return fmt.Errorf("pool already has a virtual ip %s", ip.IPAddress)
}
}
ec := newEventCtx()
err = nil
defer f.afterEvent(afterHostAdd, ec, entity, err)
if err = f.beforeEvent(beforeHostAdd, ec, entity); err != nil {
return err
}
now := time.Now()
entity.CreatedAt = now
entity.UpdatedAt = now
if err = f.hostStore.Put(ctx, host.HostKey(entity.ID), entity); err != nil {
return err
}
err = zkAPI(f).AddHost(entity)
return err
}
// UpdateHost information for a registered host
func (f *Facade) UpdateHost(ctx datastore.Context, entity *host.Host) error {
glog.V(2).Infof("Facade.UpdateHost: %+v", entity)
// validate the host exists
if host, err := f.GetHost(ctx, entity.ID); err != nil {
return err
} else if host == nil {
return fmt.Errorf("host does not exist: %s", entity.ID)
}
// validate the pool exists
if pool, err := f.GetResourcePool(ctx, entity.PoolID); err != nil {
return err
} else if pool == nil {
return fmt.Errorf("pool does not exist: %s", entity.PoolID)
}
var err error
ec := newEventCtx()
defer f.afterEvent(afterHostAdd, ec, entity, err)
if err = f.beforeEvent(beforeHostAdd, ec, entity); err != nil {
return err
}
entity.UpdatedAt = time.Now()
if err = f.hostStore.Put(ctx, host.HostKey(entity.ID), entity); err != nil {
return err
}
err = zkAPI(f).UpdateHost(entity)
return err
}
func TestServicedCLI_CmdHostList_one(t *testing.T) {
hostID := "test-host-id-1"
expected, err := DefaultHostAPITest.GetHost(hostID)
if err != nil {
t.Fatal(err)
}
var actual host.Host
output := pipe(InitHostAPITest, "serviced", "host", "list", "test-host-id-1")
if err := json.Unmarshal(output, &actual); err != nil {
t.Fatalf("error unmarshaling resource: %s", err)
}
// Did you remember to update Host.Equals?
if !actual.Equals(expected) {
t.Fatalf("\ngot:\n%+v\nwant:\n%+v", actual, expected)
}
}
func buildHostMonitoringProfile(host *host.Host) error {
tags := map[string][]string{"controlplane_host_id": []string{host.ID}}
profile, err := hostPoolProfile.ReBuild("1h-ago", tags)
if err != nil {
glog.Error("Failed to create host profile: %s", err)
return err
}
//add graphs to profile
profile.GraphConfigs = make([]domain.GraphConfig, 6)
profile.GraphConfigs[0] = newCpuConfigGraph(tags, host.Cores)
profile.GraphConfigs[1] = newLoadAverageGraph(tags)
profile.GraphConfigs[2] = newRSSConfigGraph(tags, host.Memory)
profile.GraphConfigs[3] = newOpenFileDescriptorsGraph(tags)
profile.GraphConfigs[4] = newMajorPageFaultGraph(tags)
profile.GraphConfigs[5] = newPagingGraph(tags)
host.MonitoringProfile = *profile
return nil
}
