tree-wide: cleanup

[mirror_lxc.git] / src / lua-lxc / lxc.lua

--
-- lua lxc module
--
-- Copyright © 2012 Oracle.
--
-- Authors:
-- Dwight Engen <dwight.engen@oracle.com>
--
--  This library is free software; you can redistribute it and/or
--  modify it under the terms of the GNU Lesser General Public
--  License as published by the Free Software Foundation; either
--  version 2.1 of the License, or (at your option) any later version.
--
--  This library is distributed in the hope that it will be useful,
--  but WITHOUT ANY WARRANTY; without even the implied warranty of
--  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
--  Lesser General Public License for more details.
--
--  You should have received a copy of the GNU Lesser General Public
--  License along with this library; if not, write to the Free Software
--  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
--

local core   = require("lxc.core")
local lfs    = require("lfs")
local table  = require("table")
local string = require("string")
local io     = require("io")
module("lxc", package.seeall)

local lxc_path
local log_level = 3

-- lua 5.1 compat
if table.unpack == nil then
    table.unpack = unpack
end

-- the following two functions can be useful for debugging
function printf(...)
    local function wrapper(...) io.write(string.format(...)) end
    local status, result = pcall(wrapper, ...)
    if not status then
        error(result, 2)
    end
end

function log(level, ...)
    if (log_level >= level) then
        printf(os.date("%Y-%m-%d %T "))
        printf(...)
    end
end

function string:split(delim, max_cols)
    local cols = {}
    local start = 1
    local nextc
    repeat
        nextc = string.find(self, delim, start)
        if (nextc and #cols ~= max_cols - 1) then
            table.insert(cols, string.sub(self, start, nextc-1))
            start = nextc + #delim
        else
            table.insert(cols, string.sub(self, start, string.len(self)))
            nextc = nil
        end
    until nextc == nil or start > #self
    return cols
end

-- container class
container = {}
container_mt = {}
container_mt.__index = container

function container:new(lname, config)
    local lcore
    local lnetcfg = {}
    local lstats = {}

    if lname then
        if config then
            lcore = core.container_new(lname, config)
        else
            lcore = core.container_new(lname)
        end
    end

    return setmetatable({ctname = lname, core = lcore, netcfg = lnetcfg, stats = lstats}, container_mt)
end

-- methods interfacing to core functionality
function container:attach(what, ...)
    return self.core:attach(what, ...)
end

function container:config_file_name()
    return self.core:config_file_name()
end

function container:defined()
    return self.core:defined()
end

function container:init_pid()
    return self.core:init_pid()
end

function container:name()
    return self.core:name()
end

function container:start()
    return self.core:start()
end

function container:stop()
    return self.core:stop()
end

function container:shutdown(timeout)
    return self.core:shutdown(timeout)
end

function container:wait(state, timeout)
    return self.core:wait(state, timeout)
end

function container:freeze()
    return self.core:freeze()
end

function container:unfreeze()
    return self.core:unfreeze()
end

function container:running()
    return self.core:running()
end

function container:state()
    return self.core:state()
end

function container:create(template, ...)
    return self.core:create(template, ...)
end

function container:destroy()
    return self.core:destroy()
end

-- return nil if name missing
function container:rename(name)
    return self.core:rename(name)
end

function container:get_config_path()
    return self.core:get_config_path()
end

function container:set_config_path(path)
    return self.core:set_config_path(path)
end

function container:append_config_item(key, value)
    return self.core:set_config_item(key, value)
end

function container:clear_config_item(key)
    return self.core:clear_config_item(key)
end

function container:get_cgroup_item(key)
    return self.core:get_cgroup_item(key)
end

function container:get_config_item(key)
    local value
    local vals = {}

    value = self.core:get_config_item(key)

    -- check if it is a single item
    if (not value or not string.find(value, "\n")) then
        return value
    end

    -- it must be a list type item, make a table of it
    vals = value:split("\n", 1000)
    -- make it a "mixed" table, ie both dictionary and list for ease of use
    for _,v in ipairs(vals) do
        vals[v] = true
    end
    return vals
end

function container:set_cgroup_item(key, value)
    return self.core:set_cgroup_item(key, value)
end

function container:set_config_item(key, value)
    return self.core:set_config_item(key, value)
end

function container:get_keys(base)
    local ktab = {}
    local keys

    if (base) then
        keys = self.core:get_keys(base)
        base = base .. "."
    else
        keys = self.core:get_keys()
        base = ""
    end
    if (keys == nil) then
        return nil
    end
    keys = keys:split("\n", 1000)
    for _,v in ipairs(keys) do
        local config_item = base .. v
        ktab[v] = self.core:get_config_item(config_item)
    end
    return ktab
end

-- return nil or more args
function container:get_interfaces()
    return self.core:get_interfaces()
end

-- return nil or more args
function container:get_ips(...)
    return self.core:get_ips(...)
end

function container:load_config(alt_path)
    if (alt_path) then
        return self.core:load_config(alt_path)
    else
        return self.core:load_config()
    end
end

function container:save_config(alt_path)
    if (alt_path) then
        return self.core:save_config(alt_path)
    else
        return self.core:save_config()
    end
end

-- methods for stats collection from various cgroup files
-- read integers at given coordinates from a cgroup file
function container:stat_get_ints(item, coords)
    local lines = {}
    local result = {}
    local flines = self:get_cgroup_item(item)

    if (flines == nil) then
        for k,c in ipairs(coords) do
            table.insert(result, 0)
        end
    else
        for line in flines:gmatch("[^\r\n]+") do
            table.insert(lines, line)
        end
        for k,c in ipairs(coords) do
            local col

            col = lines[c[1]]:split(" ", 80)
            local val = tonumber(col[c[2]])
            table.insert(result, val)
        end
    end
    return table.unpack(result)
end

-- read an integer from a cgroup file
function container:stat_get_int(item)
    local line = self:get_cgroup_item(item)
    -- if line is nil (on an error like Operation not supported because
    -- CONFIG_MEMCG_SWAP_ENABLED isn't enabled) return 0
    return tonumber(line) or 0
end

function container:stat_match_get_int(item, match, column)
    local val
    local lines = self:get_cgroup_item(item)

    if (lines == nil) then
       return 0
    end

    for line in lines:gmatch("[^\r\n]+") do
        if (string.find(line, match)) then
            local col

            col = line:split(" ", 80)
            val = tonumber(col[column]) or 0
        end
    end

    return val
end

function container:stats_get(total)
    local stat = {}
    stat.mem_used      = self:stat_get_int("memory.usage_in_bytes")
    stat.mem_limit     = self:stat_get_int("memory.limit_in_bytes")
    stat.memsw_used    = self:stat_get_int("memory.memsw.usage_in_bytes")
    stat.memsw_limit   = self:stat_get_int("memory.memsw.limit_in_bytes")
    stat.kmem_used     = self:stat_get_int("memory.kmem.usage_in_bytes")
    stat.kmem_limit    = self:stat_get_int("memory.kmem.limit_in_bytes")
    stat.cpu_use_nanos = self:stat_get_int("cpuacct.usage")
    stat.cpu_use_user,
    stat.cpu_use_sys   = self:stat_get_ints("cpuacct.stat", {{1, 2}, {2, 2}})
    stat.blkio         = self:stat_match_get_int("blkio.throttle.io_service_bytes", "Total", 2)

    if (total) then
        total.mem_used      = total.mem_used      + stat.mem_used
        total.mem_limit     = total.mem_limit     + stat.mem_limit
        total.memsw_used    = total.memsw_used    + stat.memsw_used
        total.memsw_limit   = total.memsw_limit   + stat.memsw_limit
        total.kmem_used     = total.kmem_used     + stat.kmem_used
        total.kmem_limit    = total.kmem_limit    + stat.kmem_limit
        total.cpu_use_nanos = total.cpu_use_nanos + stat.cpu_use_nanos
        total.cpu_use_user  = total.cpu_use_user  + stat.cpu_use_user
        total.cpu_use_sys   = total.cpu_use_sys   + stat.cpu_use_sys
        total.blkio         = total.blkio         + stat.blkio
    end
    return stat
end

local M = { container = container }

function M.stats_clear(stat)
    stat.mem_used      = 0
    stat.mem_limit     = 0
    stat.memsw_used    = 0
    stat.memsw_limit   = 0
    stat.kmem_used     = 0
    stat.kmem_limit    = 0
    stat.cpu_use_nanos = 0
    stat.cpu_use_user  = 0
    stat.cpu_use_sys   = 0
    stat.blkio         = 0
end

-- return configured containers found in LXC_PATH directory
function M.containers_configured(names_only)
    local containers = {}

    for dir in lfs.dir(lxc_path) do
        if (dir ~= "." and dir ~= "..")
        then
            local cfgfile = lxc_path .. "/" .. dir .. "/config"
            local cfgattr = lfs.attributes(cfgfile)

            if (cfgattr and cfgattr.mode == "file") then
                if (names_only) then
                    -- note, this is a "mixed" table, ie both dictionary and list
                    containers[dir] = true
                    table.insert(containers, dir)
                else
                    local ct = container:new(dir)
                    -- note, this is a "mixed" table, ie both dictionary and list
                    containers[dir] = ct
                    table.insert(containers, dir)
                end
            end
        end
    end
    table.sort(containers, function (a,b) return (a < b) end)
    return containers
end

-- return running containers found in cgroup fs
function M.containers_running(names_only)
    local containers = {}
    local names = M.containers_configured(true)

    for _,name in ipairs(names) do
        local ct = container:new(name)
        if ct:running() then
                -- note, this is a "mixed" table, ie both dictionary and list
                table.insert(containers, name)
                if (names_only) then
                    containers[name] = true
                    ct = nil
                else
                    containers[name] = ct
                end
        end
    end

    table.sort(containers, function (a,b) return (a < b) end)
    return containers
end

function M.version_get()
    return core.version_get()
end

function M.default_config_path_get()
    return core.default_config_path_get()
end

function M.cmd_get_config_item(name, item, lxcpath)
    if (lxcpath) then
        return core.cmd_get_config_item(name, item, lxcpath)
    else
        return core.cmd_get_config_item(name, item)
    end
end

lxc_path = core.default_config_path_get()

return M