Ejemplo n.º 1
0
func check_backend(ch *elliptics.DChannel, s *elliptics.Session, addr *elliptics.DnetAddr, backend_id int32, ro bool, delay uint32) error {
	checked := false

	for t := range ch.Out {
		st := t.(*elliptics.DnetBackendsStatus)

		if st.Error != nil {
			return st.Error
		}

		for _, b := range st.Backends {
			if b.Backend == backend_id {
				if b.RO != ro {
					return fmt.Errorf("backend: %d: read-only mismatch: read: %v, must be: %v",
						backend_id, b.RO, ro)
				}
				if b.Delay != delay {
					return fmt.Errorf("backend: %d: delay mismatch: read: %v, must be: %v",
						backend_id, b.Delay, delay)
				}

				checked = true
				break
			}
		}
	}
	if !checked {
		return fmt.Errorf("backend: %d: could not find backend", backend_id)
	}

	checked = false
	for t := range s.BackendsStatus(addr).Out {
		st := t.(*elliptics.DnetBackendsStatus)

		if st.Error != nil {
			return st.Error
		}

		for _, b := range st.Backends {
			if b.Backend == backend_id {
				if b.RO != ro {
					return fmt.Errorf("backend: %d: check: read-only mismatch: read: %v, must be: %v",
						backend_id, b.RO, ro)
				}
				if b.Delay != delay {
					return fmt.Errorf("backend: %d: check: delay mismatch: read: %v, must be: %v",
						backend_id, b.Delay, delay)
				}

				checked = true
				break
			}
		}
	}
	if !checked {
		return fmt.Errorf("backend: %d: could not find backend", backend_id)
	}

	return nil
}
Ejemplo n.º 2
0
func (bctl *BucketCtl) SetGroupsTimeout(s *elliptics.Session, bucket *Bucket, key string) {
	// sort groups by defrag state, increase timeout if needed

	groups := make([]uint32, 0)
	defrag_groups := make([]uint32, 0)
	timeout := 30

	for group_id, sg := range bucket.Group {
		sb, err := sg.FindStatBackendKey(s, key, group_id)
		if err != nil {
			continue
		}

		if sb.DefragState != 0 {
			defrag_groups = append(defrag_groups, group_id)
		} else {
			groups = append(groups, group_id)
		}
	}

	// Not being defragmented backends first, then those which are currently being defragmented
	groups = append(groups, defrag_groups...)
	if len(groups) == len(defrag_groups) {
		timeout = 90
	}

	// if there are no backends being defragmented, use weights to mix read states
	// if there are such backends, use strict order and read from non-defragmented backends first
	ioflags := elliptics.IOflag(bctl.Conf.Proxy.ReaderIOFlags) | s.GetIOflags()
	if len(defrag_groups) == 0 {
		ioflags |= elliptics.DNET_IO_FLAGS_MIX_STATES
	}
	s.SetIOflags(ioflags)

	// there are no stats for bucket groups, use what we have in metadata
	if len(groups) == 0 {
		groups = bucket.Meta.Groups
	}

	s.SetGroups(groups)
	s.SetTimeout(timeout)
}