import docker
import re
import pprint
import datetime,time
from urllib.request import urlopen, Request, HTTPError, URLError
import json

#instantiate a client, and connect to the main manager in the swarm
#Since I am connecting to a remote host, I am using the below.
client = docker.DockerClient(base_url='tcp://192.168.5.114:2375')

#But if you intend to run this on the main manager, uncomment the below line
#client = docker.from_env()

node = client.api.nodes()          #docker node ls - only on swarm

#get current time in seconds since the Epoch
unix_seconds = time.mktime(datetime.datetime.now().timetuple())

def calculateCPUPercentUnix(previousCPU, previousSystem,v):
    cpuPercent = 0.0
	#calculate the change for the cpu usage of the container in between readings
    cpuDelta = v['cpu_stats']['cpu_usage']['total_usage'] - previousCPU
	#calculate the change for the entire system between readings
    systemDelta = v['cpu_stats']['system_cpu_usage'] - previousSystem
    if systemDelta > 0.0 and cpuDelta > 0.0:
        cpuPercent = (cpuDelta / systemDelta) * len(v['cpu_stats']['cpu_usage']['percpu_usage']) * 100
        return cpuPercent
    else:
        return cpuPercent

def systemDf(cli):
    size = []
    df = cli.api.df()['Containers'] #docker system df -v and get only container info
    for df_len in range(len(df)):
        if df[df_len]['State'] != 'exited':
            iD = df[df_len]['Id'][:10]
            size.append({iD+'-Image':re.sub(r'(.*)(@.*)',r'\1',df[df_len]['Image']),
                     iD+'-Size':(df[df_len].get('SizeRw', 0)/1000000),
                     iD+'-VirtualSize':(df[df_len].get('SizeRootFs', 0)/1000000000),
                     iD+'-Status':df[df_len]['Status'],
                     iD+'-Created':str(int((unix_seconds-df[df_len]['Created'])/(24*60*60)))+' Days ago'
                     if int((unix_seconds-df[df_len]['Created'])/(24*60*60)) <= 10 else str(int((unix_seconds-df[df_len]['Created'])/(7*24*60*60)))+' Weeks Ago',
                     iD+'-State':df[df_len]['State']
                     })
    return size

def containerMetrics(cli):
    mem = []
    container_node = cli.api.containers() #docker ps
    cont = [container_node[i]['Id'][:10] for i in range(len(container_node))]
    for cont_id in range(len(cont)):
            #Get container stats
            stats = cli.api.stats(cont[cont_id],stream=False)
            name = re.sub(r'(\W*)(\w*)(\..*)?',r'\2',str(stats['name']))
            previousCPU = stats['precpu_stats']['cpu_usage']['total_usage']
            previousSystem = stats['precpu_stats']['system_cpu_usage']
            cpuPercent = calculateCPUPercentUnix(previousCPU, previousSystem,stats)
            service = cli.api.inspect_container(cont[cont_id])['Config']['Labels']
            mem.append({cont[cont_id]+'-ContainerName':name,cont[cont_id]+'-ContainerId':cont[cont_id],
                cont[cont_id]+'-MemUsage':(stats['memory_stats']['usage']-stats['memory_stats']['stats']['cache'])/1048576, #Convert to MiB
                cont[cont_id]+'-MaxMem':stats['memory_stats']['limit']/1073741824,cont[cont_id]+'-CpuPercent':cpuPercent,
                cont[cont_id]+'-ContainerNode':node_ip,cont[cont_id]+'-ServiceName':service['com.docker.swarm.service.name']
                if 'com.docker.swarm.service.name' in service else 'None',cont[cont_id]+'-ServiceID':service['com.docker.swarm.service.id'][:10]
                if 'com.docker.swarm.service.id' in service else 'None' })
    return mem

def imageInfo(cli):
    image_info = []
    #Get image info, when you do a docker system df -v, Containers per image/created/size/unique size/name of each image
    image = cli.api.df()['Images'] #docker system df -v and get only image info
    for i in range(len(image)):
        image_iD = re.sub(r'(.*:)(.*)',r"\2",image[i]['Id'])[:10]
        image_info.append({image_iD+'-Name':str(image[i]['RepoTags']).strip("['']"),
               image_iD+'-Containers':image[i]['Containers'],
               image_iD+'-Size':image[i]['Size']/1000000,
               #as per docker docs UNIQUE SIZE is the amount of space that is only used by a given image
               #UNIQUE SIZE = SIZE - SHARED SIZE
               image_iD+'-UniqueSize':(image[i]['Size']-image[i]['SharedSize'])/1000000,
               image_iD+'-Created':str(int((unix_seconds-image[i]['Created'])/(24*60*60)))+' Days ago'
               if int((unix_seconds-image[i]['Created'])/(24*60*60)) <= 10 else str(int((unix_seconds-image[i]['Created'])/(7*24*60*60)))+' Weeks Ago',
               image_iD+'-ImageNode':node_ip
               })
    return image_info

#get the system info
NodeInfo = []
SystemDF = []
ContainerMetrics = []
ImageInfo = []


for node_index in range(len(node)):
    node_ip = node[node_index]['Status']['Addr']
    #connect to all nodes in the swarm and pull info
    cli = docker.DockerClient(base_url='tcp://'+node_ip+':2375')
    #docker info
    sys = cli.api.info()
    node_addr=sys['Swarm']['NodeAddr']
    #NodeInfo = []
    NodeInfo.append({node_addr+'-NodeName':sys['Name'],node_addr+'-NodeID':sys['Swarm']['NodeID'][:10],
         node_addr+'-Containers':sys['Containers'],node_addr+'-ContainersRunning':sys['ContainersRunning'],
         node_addr+'-Images':sys['Images'],
         node_addr+'-OperatingSystem':sys['OperatingSystem'],
         node_addr+'-State':str(node[node_index]['Status']['State']).capitalize(),
         node_addr+'-Role':str(node[node_index]['Spec']['Role']).capitalize(),
         node_addr+'-Availability':str(node[node_index]['Spec']['Availability']).capitalize()})
    #If node is a manager add the following details
    if node[node_index]['Spec']['Role'] == 'manager':
        NodeInfo[node_index][node_addr+'-Managers'] = sys['Swarm']['Managers']
        NodeInfo[node_index][node_addr+'-Nodes'] = sys['Swarm']['Nodes']

    ContainerMetrics.extend(containerMetrics(cli))
    SystemDF.extend(systemDf(cli))

    # ** is called dictionary unpacking.
    #It splits the contents of the dictionary into its respective key-value pairs and allows you to merge them into one dictionary.
    ContainerMetrics = [{**a, **b} for a, b in zip(ContainerMetrics,SystemDF)]

    ImageInfo.extend(imageInfo(cli))


'''
pprint.pprint(ContainerMetrics)
print('\n')
pprint.pprint(NodeInfo)
print('\n')
pprint.pprint(ImageInfo)
'''