--- | Compute online nodes from a NodeList
-getOnline :: NodeList -> [Node.Node]
-getOnline = filter (not . Node.offline) . Container.elems
-
--- | Try to allocate an instance on the cluster
-tryAlloc :: (Monad m) =>
- NodeList
- -> InstanceList
- -> Instance.Instance
- -> Int
- -> m [(Maybe NodeList, [Node.Node])]
-tryAlloc nl _ inst 2 =
- let all_nodes = getOnline nl
- all_pairs = liftM2 (,) all_nodes all_nodes
- ok_pairs = filter (\(x, y) -> Node.idx x /= Node.idx y) all_pairs
- sols = map (\(p, s) ->
- (fst $ Cluster.allocateOnPair nl inst p s, [p, s]))
- ok_pairs
- in return sols
-
-tryAlloc nl _ inst 1 =
- let all_nodes = getOnline nl
- sols = map (\p -> (fst $ Cluster.allocateOnSingle nl inst p, [p]))
- all_nodes
- in return sols
-
-tryAlloc _ _ _ reqn = fail $ "Unsupported number of alllocation \
- \destinations required (" ++ (show reqn) ++
- "), only two supported"
-
--- | Try to allocate an instance on the cluster
-tryReloc :: (Monad m) =>
- NodeList
- -> InstanceList
- -> Int
- -> Int
- -> [Int]
- -> m [(Maybe NodeList, [Node.Node])]
-tryReloc nl il xid 1 ex_idx =
- let all_nodes = getOnline nl
- inst = Container.find xid il
- ex_idx' = (Instance.pnode inst):ex_idx
- valid_nodes = filter (not . flip elem ex_idx' . idx) all_nodes
- valid_idxes = map Node.idx valid_nodes
- sols1 = map (\x -> let (mnl, _, _, _) =
- Cluster.applyMove nl inst
- (Cluster.ReplaceSecondary x)
- in (mnl, [Container.find x nl])
- ) valid_idxes
- in return sols1
-
-tryReloc _ _ _ reqn _ = fail $ "Unsupported number of relocation \
- \destinations required (" ++ (show reqn) ++
- "), only one supported"
-
-filterFails :: (Monad m) => [(Maybe NodeList, [Node.Node])]
- -> m [(NodeList, [Node.Node])]
-filterFails sols =
- if null sols then fail "No nodes onto which to allocate at all"
- else let sols' = filter (isJust . fst) sols
- in if null sols' then
- fail "No valid allocation solutions"
- else
- return $ map (\(x, y) -> (fromJust x, y)) sols'
-
-processResults :: (Monad m) => [(NodeList, [Node.Node])]
- -> m (String, [Node.Node])
-processResults sols =
- let sols' = map (\(nl', ns) -> (Cluster.compCV nl', ns)) sols
- sols'' = sortBy (compare `on` fst) sols'
- (best, w) = head sols''
- (worst, l) = last sols''
- info = printf "Valid results: %d, best score: %.8f for node(s) %s, \
- \worst score: %.8f for node(s) %s" (length sols'')
- best (intercalate "/" . map Node.name $ w)
- worst (intercalate "/" . map Node.name $ l)
- in return (info, w)
+processResults :: (Monad m) =>
+ RqType -> Cluster.AllocSolution
+ -> m Cluster.AllocSolution
+processResults _ (Cluster.AllocSolution { Cluster.asSolutions = [],
+ Cluster.asLog = msgs }) =
+ fail $ intercalate ", " msgs
+
+processResults (Evacuate _) as = return as
+
+processResults _ as =
+ case Cluster.asSolutions as of
+ _:[] -> return as
+ _ -> fail "Internal error: multiple allocation solutions"
+
+-- | Process a request and return new node lists
+processRequest :: Request
+ -> Result Cluster.AllocSolution
+processRequest request =
+ let Request rqtype (ClusterData gl nl il _) = request
+ in case rqtype of
+ Allocate xi reqn -> Cluster.tryMGAlloc gl nl il xi reqn
+ Relocate idx reqn exnodes -> Cluster.tryReloc nl il idx reqn exnodes
+ Evacuate exnodes -> Cluster.tryEvac nl il exnodes
+
+-- | Reads the request from the data file(s)
+readRequest :: Options -> [String] -> IO Request
+readRequest opts args = do
+ when (null args) $ do
+ hPutStrLn stderr "Error: this program needs an input file."
+ exitWith $ ExitFailure 1
+
+ input_data <- readFile (head args)
+ r1 <- case (parseData input_data) of
+ Bad err -> do
+ hPutStrLn stderr $ "Error: " ++ err
+ exitWith $ ExitFailure 1
+ Ok rq -> return rq
+ r2 <- if isJust (optDataFile opts) || (not . null . optNodeSim) opts
+ then do
+ cdata <- loadExternalData opts
+ let Request rqt _ = r1
+ return $ Request rqt cdata
+ else return r1
+ return r2