Synnefo » snf-ganeti » ganeti-local

    , oMachineReadable

-- | The kind of instance spec we print.

data SpecType = SpecNormal

              | SpecTiered

-- | What we prefix a spec with.

specPrefix :: SpecType -> String

specPrefix SpecNormal = "SPEC"

specPrefix SpecTiered = "TSPEC_INI"

-- | The description of a spec.

specDescription :: SpecType -> String

specDescription SpecNormal = "Normal (fixed-size)"

specDescription SpecTiered = "Tiered (initial size)"

-- | Efficiency generic function.

effFn :: (Cluster.CStats -> Integer)

      -> (Cluster.CStats -> Double)

      -> (Cluster.CStats -> Double)

effFn fi ft cs = fromIntegral (fi cs) / ft cs

-- | Memory efficiency.

memEff :: Cluster.CStats -> Double

memEff = effFn Cluster.csImem Cluster.csTmem

-- | Disk efficiency.

dskEff :: Cluster.CStats -> Double

dskEff = effFn Cluster.csIdsk Cluster.csTdsk

-- | Cpu efficiency.

cpuEff :: Cluster.CStats -> Double

cpuEff = effFn Cluster.csIcpu (fromIntegral . Cluster.csVcpu)

            , ("MEM_EFF", printf "%.8f" . memEff)

            , ("DSK_EFF", printf "%.8f" . dskEff)

            , ("CPU_EFF", printf "%.8f" . cpuEff)

-- | Print final stats and related metrics.

printResults :: Bool -> Node.List -> Node.List -> Int -> Int

             -> [(FailMode, Int)] -> IO ()

printResults True _ fin_nl num_instances allocs sreason = do

printResults False ini_nl fin_nl _ allocs sreason = do

  putStrLn "Normal (fixed-size) allocation results:"

  printf "  - %3d instances allocated\n" allocs :: IO ()

  printf "  - most likely failure reason: %s\n" $ failureReason sreason::IO ()

  printClusterScores ini_nl fin_nl

  printClusterEff (Cluster.totalResources fin_nl)

-- | Prints the final @OK@ marker in machine readable output.

printFinal :: Bool -> IO ()

printFinal True =

printFinal False = return ()

-- | Formats nicely a list of resources.

formatResources :: a -> [(String, (a->String))] -> String

formatResources res =

    intercalate ", " . map (\(a, fn) -> a ++ " " ++ fn res)

-- | Print the cluster resources.

printCluster :: Bool -> Cluster.CStats -> Int -> IO ()

printCluster True ini_stats node_count = do

  printKeys $ map (\(a, fn) -> ("CLUSTER_" ++ a, fn ini_stats)) clusterData

  printKeys [("CLUSTER_NODES", printf "%d" node_count)]

  printKeys $ printStats PInitial ini_stats

printCluster False ini_stats node_count = do

  printf "The cluster has %d nodes and the following resources:\n  %s.\n"

         node_count (formatResources ini_stats clusterData)::IO ()

  printf "There are %s initial instances on the cluster.\n"

             (if inst_count > 0 then show inst_count else "no" )

      where inst_count = Cluster.csNinst ini_stats

-- | Prints the normal instance spec.

printISpec :: Bool -> RSpec -> SpecType -> DiskTemplate -> IO ()

printISpec True ispec spec disk_template = do

  printKeys $ map (\(a, fn) -> (prefix ++ "_" ++ a, fn ispec)) specData

  printKeys [ (prefix ++ "_RQN", printf "%d" req_nodes) ]

  printKeys [ (prefix ++ "_DISK_TEMPLATE", dtToString disk_template) ]

      where req_nodes = Instance.requiredNodes disk_template

            prefix = specPrefix spec

printISpec False ispec spec disk_template = do

  printf "%s instance spec is:\n  %s, using disk\

         \ template '%s'.\n"

         (specDescription spec)

         (formatResources ispec specData) (dtToString disk_template)

-- | Prints the tiered results.

printTiered :: Bool -> [(RSpec, Int)] -> Double

            -> Node.List -> Node.List -> [(FailMode, Int)] -> IO ()

printTiered True spec_map m_cpu nl trl_nl _ = do

  printKeys $ printStats PTiered (Cluster.totalResources trl_nl)

  printKeys [("TSPEC", intercalate " " (formatSpecMap spec_map))]

  printAllocationStats m_cpu nl trl_nl

printTiered False spec_map _ ini_nl fin_nl sreason = do

  _ <- printf "Tiered allocation results:\n"

  mapM_ (\(ispec, cnt) ->

             printf "  - %3d instances of spec %s\n" cnt

                        (formatResources ispec specData)) spec_map

  printf "  - most likely failure reason: %s\n" $ failureReason sreason::IO ()

  printClusterScores ini_nl fin_nl

  printClusterEff (Cluster.totalResources fin_nl)

printClusterScores :: Node.List -> Node.List -> IO ()

printClusterScores ini_nl fin_nl = do

  printf "  - initial cluster score: %.8f\n" $ Cluster.compCV ini_nl::IO ()

  printf "  -   final cluster score: %.8f\n" $ Cluster.compCV fin_nl

printClusterEff :: Cluster.CStats -> IO ()

printClusterEff cs =

    mapM_ (\(s, fn) ->

               printf "  - %s usage efficiency: %5.2f%%\n" s (fn cs * 100))

          [("memory", memEff),

           ("  disk", dskEff),

           ("  vcpu", cpuEff)]

-- | Computes the most likely failure reason.

failureReason :: [(FailMode, Int)] -> String

failureReason = show . fst . head

-- | Sorts the failure reasons.

sortReasons :: [(FailMode, Int)] -> [(FailMode, Int)]

sortReasons = reverse . sortBy (comparing snd)

      machine_r = optMachineReadable opts

  printCluster machine_r ini_stats (length all_nodes)

  printISpec machine_r ispec SpecNormal disk_template

       (treason, trl_nl, trl_il, trl_ixes, _) <-

           treason' = sortReasons treason

       printISpec machine_r tspec SpecTiered disk_template

       printTiered machine_r spec_map' m_cpu nl trl_nl treason'

       )

      sreason = sortReasons ereason

  printResults machine_r nl fin_nl num_instances allocs sreason

  printFinal machine_r