ceilometer

#!/usr/bin/env python

import calendar
import ConfigParser
import errno
import httplib
import json
import math
import optparse
import os
import socket
import sys
import time

from filelock import FileLock

class api_response():
    __status = None
    __data = None
    __msg = None

    def __init__(self, status, data, msg):
        self.setStatus(status)
        self.setData(data)
        self.setMsg(msg)

    def setStatus(self, status):
        self.__status = status

    def getStatus(self):
        return self.__status

    def setData(self, data):
        self.__data = data

    def getData(self):
        return self.__data

    def setMsg(self, msg):
        self.__msg = msg

    def getMsg(self):
        return self.__msg

class api_request():
    @staticmethod
    def call(protocol, url, host, port, header, params=None):
        if (protocol == 'http'):
            conn = httplib.HTTPConnection(host, port)
        else:
            conn = httplib.HTTPSConnection(host, port)
        try:
            if params is None:
                conn.request("GET", url, headers = header)
            else:
                conn.request("POST", url, params, header)
        except socket.error as e:
            print 'Exception: ' + str(e)
            sys.exit()

        res = conn.getresponse()
        response = api_response(res.status, res.read(), res.msg)

        return response

def getToken(protocol, server, port, tenant, username, password):
    token_file_path = os.path.join(os.path.dirname(__file__), 'token_backup')
    parser_token = ConfigParser.SafeConfigParser()

    with FileLock(token_file_path):
        parser_token.readfp(open(token_file_path))

    if (not parser_token.get('token', 'expires')) or (int(float(parser_token.get('token', 'expires')) - time.time()) <= 0):
        params = '{"auth": {"tenantName": "%s", "passwordCredentials": {"username": "%s", "password": "%s"}}}' % (tenant, username, password)
        header = {"Content-Type": "application/json", "Accept": "application/json"}
        res = api_request.call(protocol, '/v2.0/tokens', server, port, header, params)
        res_json = json.loads(res.getData())
        
        try:
            timestamp = calendar.timegm(time.strptime(res_json['access']['token']['expires'],"%Y-%m-%dT%H:%M:%SZ"))
            parser_token.set('token','id', res_json['access']['token']['id'])
            parser_token.set('token', 'expires', str(timestamp))

            with FileLock(token_file_path):
                with open(token_file_path, 'w') as configfile:
                    parser_token.write(configfile)
        except KeyError as e:
            print 'Exception: Wrong Keystone Credentials'
            sys.exit()

    return parser_token.get('token', 'id')

def getMeter(protocol, server, port, token_id, meter, resource_id):
    if meter in ('cpu', 'cpu_util', 'disk.ephemeral.size', 'disk.root.size', 'memory', 'vcpus'):
        url = "/v2/meters/%s?q.field=resource_id&q.op=eq&q.value=%s&limit=1" % (meter, resource_id)
    elif meter in ('network.incoming.bytes', 'network.outgoing.bytes'):
        url = "/v2/meters/%s?q.field=metadata.instance_id&q.op=eq&q.value=%s&limit=1" % (meter, resource_id)
    else:
        return "Unknown Meter"

    try:
        res_json = json.loads(api_request.call(protocol, url, server, port, {"X-Auth-Token": token_id}).getData())
        if res_json:
            return res_json[0]['counter_volume']
        else:
            return 'Sample Not Found'

    except ValueError as e:
        print 'Exception: Wrong Ceilometer Port'
        sys.exit()

def main():
    config_file_path = os.path.join(os.path.dirname(__file__), 'credentials.conf')
    parser_config = ConfigParser.SafeConfigParser()
    parser_config.readfp(open(config_file_path))
    
    token_id = getToken(
        parser_config.get('keystone', 'protocol'),
        parser_config.get('keystone', 'server'),
        parser_config.get('keystone', 'port'),
        parser_config.get('keystone', 'tenant'),
        parser_config.get('keystone', 'username'),
        parser_config.get('keystone', 'password')
    )

    print getMeter(
        parser_config.get('ceilometer', 'protocol'),
        parser_config.get('ceilometer', 'server'),
        parser_config.get('ceilometer', 'port'),
        token_id,
        sys.argv[1],
        sys.argv[2]
    )

if __name__ == "__main__":
    main()