#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
 #the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import time
import datetime
import re
import json
import hashlib
import plugins.utils.jsonapi
import threading
import requests.exceptions
import os

"""
This is the Kibble Jenkins scanner plugin.
"""

title = "Scanner for Jenkins CI"
version = "0.1.0"

def accepts(source):
    """ Determines whether we want to handle this source """
    if source['type'] == 'jenkins':
        return True
    return False


def scanJob(KibbleBit, source, job, creds):
    """ Scans a single job for activity """
    NOW = int(datetime.datetime.utcnow().timestamp())
    dhash = hashlib.sha224( ("%s-%s-%s" % (source['organisation'], source['sourceURL'], job['name']) ).encode('ascii', errors='replace')).hexdigest()
    found = True
    doc= None
    parseIt = False
    found = KibbleBit.exists('cijob', dhash)
    
    # Get $jenkins/job/$job-name/json...
    jobURL = os.path.join(source['sourceURL'], "job/%s/api/json?depth=2&tree=builds[number,status,timestamp,id,result,duration]" % job['name'])
    KibbleBit.pprint(jobURL)
    jobjson = plugins.utils.jsonapi.get(jobURL, auth = creds)
    
    # If valid JSON, ...
    if jobjson:
        for build in jobjson.get('builds', []):
            buildhash = hashlib.sha224( ("%s-%s-%s-%s" % (source['organisation'], source['sourceURL'], job['name'], build['id']) ).encode('ascii', errors='replace')).hexdigest()
            builddoc = None
            try:
                builddoc = KibbleBit.get('ci_build', buildhash)
            except:
                pass
            
            # If this build already completed, no need to parse it again
            if builddoc and builddoc.get('completed', False):
                continue
            
            KibbleBit.pprint("[%s-%s] This is new or pending, analyzing..." % (job['name'], build['id']))
            
            completed = True if build['result'] else False
            
            # Estimate time spent in queue
            queuetime = 0
            TS = int(build['timestamp']/1000)
            if builddoc:
                queuetime = builddoc.get('queuetime', 0)
            if not completed:
                queuetime = NOW - TS
            
            # Get build status (success, failed, canceled etc)
            status = 'building'
            if build['result'] in ['SUCCESS', 'STABLE']:
                status = 'success'
            if build['result'] in ['FAILURE', 'UNSTABLE']:
                status = 'failed'
            if build['result'] in ['ABORTED']:
                status = 'aborted'
                
            doc = {
                # Build specific data
                'id': buildhash,
                'buildID': build['id'],
                'completed': completed,
                'duration': build['duration'],
                'job': job['name'],
                'status': status,
                'started': build['timestamp'],
                'ci': 'jenkins',
                'queuetime': queuetime,
                
                # Standard docs values
                'sourceID': source['sourceID'],
                'organisation': source['organisation'],
                'upsert': True,
            }
            KibbleBit.append('ci_build', doc)
        # Yay, it worked!
        return True
    
    # Boo, it failed!
    KibbleBit.pprint("Fetching job data failed!")
    return False


class jenkinsThread(threading.Thread):
    """ Generic thread class for scheduling multiple scans at once """
    def __init__(self, block, KibbleBit, source, creds, jobs):
        super(jenkinsThread, self).__init__()
        self.block = block
        self.KibbleBit = KibbleBit
        self.creds = creds
        self.source = source
        self.jobs = jobs
        
    def run(self):
        badOnes = 0
        while len(self.jobs) > 0 and badOnes <= 50:
            self.block.acquire()
            try:
                job = self.jobs.pop(0)
            except Exception as err:
                self.block.release()
                return
            if not job:
                self.block.release()
                return
            self.block.release()
            if not scanJob(self.KibbleBit, self.source, job, self.creds):
                self.KibbleBit.pprint("[%s] This borked, trying another one" % job['name'])
                badOnes += 1
                if badOnes > 100:
                    self.KibbleBit.pprint("Too many errors, bailing!")
                    self.source['steps']['issues'] = {
                        'time': time.time(),
                        'status': 'Too many errors while parsing at ' + time.strftime("%Y/%m/%d %H:%M:%S", time.gmtime(time.time())),
                        'running': False,
                        'good': False
                    }
                    self.KibbleBit.updateSource(self.source)
                    return
            else:
                badOnes = 0

def scan(KibbleBit, source):
    # Simple URL check
    jenkins = re.match(r"(https?://.+)", source['sourceURL'])
    if jenkins:
        
        source['steps']['jenkins'] = {
            'time': time.time(),
            'status': 'Parsing Jenkins job changes...',
            'running': True,
            'good': True
        }
        KibbleBit.updateSource(source)
        
        badOnes = 0
        pendingJobs = []
        KibbleBit.pprint("Parsing Jenkins activity at %s" % source['sourceURL'])
        source['steps']['issues'] = {
            'time': time.time(),
            'status': 'Downloading changeset',
            'running': True,
            'good': True
        }
        KibbleBit.updateSource(source)
        
        # Jenkins may neeed credentials
        creds = None
        if source['creds'] and 'username' in source['creds'] and source['creds']['username'] and len(source['creds']['username']) > 0:
            creds = "%s:%s" % (source['creds']['username'], source['creds']['password'])
            
        # Get the job list
        sURL = source['sourceURL']
        KibbleBit.pprint("Getting job list...")
        jobsjs = plugins.utils.jsonapi.get("%s/api/json?tree=jobs[name,color]&depth=1" % sURL , auth = creds)
        
        # Get the current queue
        KibbleBit.pprint("Getting job queue...")
        queuejs = plugins.utils.jsonapi.get("%s/queue/api/json?depth=1" % sURL , auth = creds)
        
        # Save queue snapshot
        NOW = int(datetime.datetime.utcnow().timestamp())
        queuehash = hashlib.sha224( ("%s-%s-queue-%s" % (source['organisation'], source['sourceURL'], int(time.time())) ).encode('ascii', errors='replace')).hexdigest()
        
        
        # Scan queue items
        blocked = 0
        stuck = 0
        totalqueuetime = 0
        items = queuejs.get('items', [])
        
        for item in items:
            if item['blocked']:
                blocked += 1
            if item['stuck']:
                stuck += 1
            if 'inQueueSince' in item:
                totalqueuetime += (NOW - int(item['inQueueSince']/1000))
        
        avgqueuetime = totalqueuetime / max(1, len(items))
        
        # Write up a queue doc
        queuedoc = {
            'id': queuehash,
            'date': time.strftime("%Y/%m/%d %H:%M:%S", time.gmtime(NOW)),
            'time': NOW,
            'size': len(items),
            'blocked': blocked,
            'stuck': stuck,
            'avgwait': avgqueuetime,
            'ci': 'jenkins',
            
            # Standard docs values
            'sourceID': source['sourceID'],
            'organisation': source['organisation'],
            'upsert': True,
        }
        KibbleBit.append('ci_queue', queuedoc)
        
        pendingJobs = jobsjs.get('jobs', [])
        KibbleBit.pprint("Found %u jobs in Jenkins" % len(pendingJobs))
        
        threads = []
        block = threading.Lock()
        KibbleBit.pprint("Scanning jobs using 4 sub-threads")
        for i in range(0,4):
            t = jenkinsThread(block, KibbleBit, source, creds, pendingJobs)
            threads.append(t)
            t.start()
        
        for t in threads:
            t.join()

        # We're all done, yaay        
        KibbleBit.pprint("Done scanning %s" % source['sourceURL'])

        source['steps']['issues'] = {
            'time': time.time(),
            'status': 'Jenkins successfully scanned at ' + time.strftime("%Y/%m/%d %H:%M:%S", time.gmtime(time.time())),
            'running': False,
            'good': True
        }
        KibbleBit.updateSource(source)