Synnefo » snf-ganeti » ganeti-local

import Ganeti.BasicTypes

import qualified Ganeti.HTools.Container as Container

import qualified Ganeti.HTools.Instance as Instance

import qualified Ganeti.HTools.Node as Node

import qualified Ganeti.HTools.Group as Group

import Ganeti.HTools.Types

  in return $ annotateSolution sols

-- | Given a group/result, describe it as a nice (list of) messages.

  case result of

    Ok solution -> map (printf "Group %s (%s): %s" gname pol) (asLog solution)

    Bad message -> [printf "Group %s: error %s" gname message]

        pol = allocPolicyToRaw (Group.allocPolicy grp)

-- | From a list of possibly bad and possibly empty solutions, filter

-- only the groups with a valid result. Note that the result will be

-- reversed compared to the original list.

          case rasol of

            Bad _ -> accu

            Ok sol | isNothing (asSolution sol) -> accu

-- | Sort multigroup results based on policy and score.

  let extractScore (_, _, _, x) = x

                             (extractScore . fromJust . asSolution) sol)

  in sortBy (comparing solScore) sols

-- | Finds the best group for an instance on a multi-group cluster.

--

-- Only solutions in @preferred@ and @last_resort@ groups will be

                   -> Maybe [Gdx]          -- ^ The allowed groups

                   -> Instance.Instance    -- ^ The instance to allocate

                   -> Int                  -- ^ Required number of nodes

findBestAllocGroup mggl mgnl mgil allowed_gdxs inst cnt =

                allowed_gdxs

  in case sortedSols of

       [] -> Bad $ if null groups'

                     then "no groups for evacuation: allowed groups was" ++

tryMGAlloc mggl mgnl mgil inst cnt = do

  (best_group, solution, all_msgs) <-

      findBestAllocGroup mggl mgnl mgil Nothing inst cnt

      selmsg = "Selected group: " ++ group_name

  return $ solution { asLog = selmsg:all_msgs }

                  let solution = do

                        let ncnt = Instance.requiredNodes $

                                   Instance.diskTemplate inst

                                       (Just target_gdxs) inst ncnt

                        av_nodes <- availableGroupNodes group_ndx

                                    excl_ndx gdx

                        nodeEvacInstance nl il ChangeAll inst gdx av_nodes

                [(Gdx, (Node.List, Instance.List))]

splitCluster nl il =

  let ngroups = Node.computeGroups (Container.elems nl)

           let nidxs = map Node.idx nodes

               nodes' = zip nidxs nodes

               instances = Container.filter ((`elem` nidxs) . Instance.pNode) il

-- | Compute the list of nodes that are to be evacuated, given a list

-- of instances and an evacuation mode.