       (when (> (count peers) peer-counts)
         (let [n (- (count peers) peer-counts)
               peers-to-drop (drop-peers new (:job allocation) n)]
-          (when (some #{(:id state)} (into #{} peers-to-drop))
+          (when (some #{(:id state)} peers-to-drop)
             true))))
     true))
 

        required (get allocations job)
        actual (count (apply concat (vals (get-in old [:allocations (:job allocation)]))))]
    (when (> actual required)
      (let [peers-to-drop (drop-peers new (:job allocation) (- actual required))]
        (some #{(:id state)} (into #{} peers-to-drop))))))

(defmethod reallocate-from-task? :onyx.task-scheduler/percentage
  [scheduler old new job state]


(defmethod reallocate-from-job? :onyx.job-scheduler/round-robin
  [scheduler old new state]
  (boolean
    (if-let [allocation (peer->allocated-job (:allocations new) (:id state))]
      (let [peer-counts (balance-jobs new)
            peers (get (job->peers new) (:job allocation))]
        (when (> (count peers) (get peer-counts (:job allocation)))
          (let [n (- (count peers) (get peer-counts (:job allocation)))
                peers-to-drop (drop-peers new (:job allocation) n)]
            (some #{(:id state)} peers-to-drop))))
      true)))

(defmethod reallocate-from-job? :onyx.job-scheduler/percentage
  [scheduler old new state]
