Synnefo » snf-ganeti » ganeti-local

                      printf "replace-disks -n %s %s" d i])

{-| Converts a placement to string format -}

    let

        pmlen = (2*nmlen + 1)

        (i, p, s, c) = plc

        inst = Container.find i il

        inam = Instance.name inst

        (moves, cmds) =  computeMoves inam opri osec npri nsec

        ostr = (printf "%s:%s" opri osec)::String

        nstr = (printf "%s:%s" npri nsec)::String

        zip [1..] cmd_strs

{-| Converts a solution to string format -}

              -> [Placement]

              -> ([String], [[String]])

    let

    in

            zip sol [1..]

-- | Print the node list.

-}

iterateDepth :: Cluster.Table    -- ^ The starting table

             -> Int              -- ^ Remaining length

             -> Int              -- ^ Max node name len

             -> Int              -- ^ Max instance name len

             -> [[String]]       -- ^ Current command list

             -> Cluster.Score    -- ^ Score at which to stop

             -> IO (Cluster.Table, [[String]]) -- ^ The resulting table and

                                               -- commands

             cmd_strs oneline min_score =

    let Cluster.Table ini_nl ini_il ini_cv ini_plc = ini_tbl

        all_inst = Container.elems ini_il

    in

      do

        let

                               nmlen imlen (head fin_plc) fin_plc_len

            upd_cmd_strs = cmds:cmd_strs

        unless (oneline || fin_plc_len == ini_plc_len) $ do

          hFlush stdout

        (if fin_cv < ini_cv then -- this round made success, try deeper

             if allowed_next && fin_cv > min_score

                  nmlen imlen upd_cmd_strs oneline min_score

             -- don't go deeper, but return the better solution

             else return (fin_tbl, upd_cmd_strs)

  let oneline = optOneline opts

      verbose = optVerbose opts

  let offline_names = optOffline opts

      offline_wrong = filter (\n -> not $ elem n all_names) offline_names

  when (length offline_wrong > 0) $ do

         printf "Wrong node name(s) set as offline: %s\n"

                      printf "Initial score: %.8f\n" ini_cv)

  unless oneline $ putStrLn "Trying to minimize the CV..."

  (fin_tbl, cmd_strs) <- iterateDepth ini_tbl (optMaxLength opts)

  let (Cluster.Table fin_nl _ fin_cv fin_plc) = fin_tbl

      ord_plc = reverse fin_plc

      sol_msg = if null fin_plc

         hPutStrLn stderr "Error: this program doesn't take any arguments."

         exitWith $ ExitFailure 1

  printf "Loaded %d nodes, %d instances\n"

             (Container.size nl)

         (Cluster.printStats ns)

  printf "Solution (delta=%d):\n" $! min_d

  putStr $ unlines $ sol_strs

  when (optShowCmds opts) $

       do

    in unlines nlines

-- | Generate instance file data from instance objects

        nlines = map

                 (\inst ->

                      let

                          iname = Instance.name inst ++ csf

                      in

                        printf "%s|%d|%d|%s|%s|%s"

                               iname (Instance.mem inst) (Instance.dsk inst)

                 Bad err -> printf "\nError: failed to load data. \

                                   \Details:\n%s\n" err

                 Ok x -> do

                       (_, fix_nl) = Loader.checkData nl il

                   putStrLn $ printCluster fix_nl il

                   when (optShowNodes opts) $ do

                           putStr $ Cluster.printNodes fix_nl

                   let ndata = serializeNodes nl csf

                       oname = odir </> (fixSlash name)

                   writeFile (oname <.> "nodes") ndata

                   writeFile (oname <.> "instances") idata)