func syncDir(store Store, dir directory, path string, idsArg []string) {
_, dirKeys, ids := join.HashJoin(join.StringSlice(dir.keys()),
join.StringSlice(idsArg), nil, nil)
var etcdLog string
for _, dirKey := range dirKeys {
id := dirKey.(string)
keyPath := fmt.Sprintf("%s/%s", path, id)
err := store.Delete(keyPath)
if err != nil {
etcdLog = fmt.Sprintf("Failed to delete %s: %s", keyPath, err)
}
delete(dir, id)
}
for _, idElem := range ids {
id := idElem.(string)
if _, ok := dir[id]; ok {
continue
}
key := fmt.Sprintf("%s/%s", path, id)
if err := store.Mkdir(key); err != nil {
etcdLog = fmt.Sprintf("Failed to create dir %s: %s", key, err)
continue
}
dir[id] = map[string]string{}
}
// Etcd failure leads to a bunch of useless errors. Therefore we only log once.
if etcdLog != "" {
log.Error(etcdLog)
}
}
func updateIPs(namespace string, dev string, currIPs []string,
targetIPs []string) error {
_, ipToDel, ipToAdd := join.HashJoin(join.StringSlice(currIPs),
join.StringSlice(targetIPs), nil, nil)
for _, ip := range ipToDel {
if err := delIP(namespace, ip.(string), dev); err != nil {
return err
}
}
for _, ip := range ipToAdd {
if err := addIP(namespace, ip.(string), dev); err != nil {
return err
}
}
return nil
}
func readLabelTransact(view db.Database, dir directory) {
lKey := func(val interface{}) interface{} {
return val.(db.Label).Label
}
pairs, dbls, dirKeys := join.HashJoin(db.LabelSlice(view.SelectFromLabel(nil)),
join.StringSlice(dir.keys()), lKey, nil)
for _, dbl := range dbls {
view.Remove(dbl.(db.Label))
}
for _, key := range dirKeys {
pairs = append(pairs, join.Pair{L: view.InsertLabel(), R: key})
}
for _, pair := range pairs {
dbl := pair.L.(db.Label)
dbl.Label = pair.R.(string)
dbl.IP = dir[dbl.Label]["IP"]
_, dbl.MultiHost = dir[dbl.Label]["MultiHost"]
view.Commit(dbl)
}
}