Synnefo » snf-ganeti » ganeti-local

-- | External tool data loader from a variety of sources.

loadExternalData :: Options

loadExternalData opts = do

  (env_node, env_inst) <- parseEnv ()

  let nodef = if optNodeSet opts then optNodeFile opts

          | otherwise -> wrapIO $ Text.loadData nodef instf

  let ldresult = input_data >>= Loader.mergeData util_data' exTags

      (case ldresult of

         Ok x -> return x

         Bad s -> do

         hPutStrLn stderr "Warning: cluster has inconsistent data:"

         hPutStrLn stderr . unlines . map (printf "  - %s") $ fix_msgs

  iobj <- mapM (\(x,y) ->

                    asJSObject y >>= parseInstance ktn x . fromJSObject) idata

  let (kti, il) = assignIndices iobj

  req_nodes <- fromObj "required_nodes" request

  optype <- fromObj "type" request

  rqtype <-

-- list and massages it into the correct format.

mergeData :: [(String, DynUtil)]  -- ^ Instance utilisation data

          -> [String]             -- ^ Exclusion tags

  let il2 = Container.fromAssocList il

      il3 = foldl' (\im (name, n_util) ->

                        case Container.findByName im name of

      csl = length common_suffix

      snl = Container.map (\n -> setName n (stripSuffix csl $ nameOf n)) nl3

      sil = Container.map (\i -> setName i (stripSuffix csl $ nameOf i)) il4

-- | Checks the cluster data for consistency.

checkData :: Node.List -> Instance.List

-- | Builds the cluster data from an URL.

loadData :: String -- ^ Unix socket to use as source

loadData master =

  E.bracket

       (L.getClient master)

            let (node_names, node_idx) = assignIndices node_data

            inst_data <- instances >>= getInstances node_names

            let (_, inst_idx) = assignIndices inst_data

       )

-- | Builds the cluster data from an URL.

loadData :: String -- ^ Cluster or URL to use as source

loadData master = do -- IO monad

  let url = formatHost master

  node_body <- getUrl $ printf "%s/2/nodes?bulk=1" url

    let (node_names, node_idx) = assignIndices node_data

    inst_data <- inst_body >>= getInstances node_names

    let (_, inst_idx) = assignIndices inst_data

-- | Builds the cluster data from node\/instance files.

loadData :: String -- ^ Cluster description in text format

loadData ndata = -- IO monad, just for consistency with the other loaders

  return $ do

    (cnt, disk, mem, cpu) <- parseDesc ndata

                                 (fromIntegral cpu) False

                         in (idx, Node.setIdx n idx)

                    ) [1..cnt]

-- | Builds the cluster data from node\/instance files.

loadData :: String -- ^ Node data in string format

         -> String -- ^ Instance data in string format

loadData nfile ifile = do -- IO monad

  ndata <- readFile nfile

  idata <- readFile ifile

    (ktn, nl) <- loadTabular ndata loadNode

    {- instance file: name mem disk status pnode snode -}

    (_, il) <- loadTabular idata (loadInst ktn)

      verbose = optVerbose opts

      shownodes = optShowNodes opts

  let offline_names = optOffline opts

      all_nodes = Container.elems fixed_nl

                 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 (isJust shownodes) $

      ispec = optISpec opts

      shownodes = optShowNodes opts

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

  printKeys [ ("SPEC_RQN", printf "%d" (optINodes opts)) ]