Checks how many script inheritance levels are possible

breaklet-max-sling-inheritance-levels.groovy

//-------------------------------------
// *** Max Inheritance Levels
//-------------------------------------
// Breaklet Config
//-------------------------------------
def breakForDurationInSec = 80

def componentsOnTestPage = 50
def inheritanceLevelsPerIteration = 10

def appsBasePath = "/apps/test"
def contentBasePath = "/content/test"

def sessionUser = 'admin'
def sessionPassword = 'admin'

def noPaddingWidth = 4

//-------------------------------------
// Breaklet
//-------------------------------------
new Breaklet(this, breakForDurationInSec, sessionUser, sessionPassword).run { breaklet, currentIt, itSession  ->

    def inheritanceLevelStart = (inheritanceLevelsPerIteration * (currentIt-1))+1
    def inheritanceLevelEnd = inheritanceLevelsPerIteration * currentIt
    for(int inheritanceLevel = inheritanceLevelStart; inheritanceLevel <= inheritanceLevelEnd; inheritanceLevel++) {

        def contentBasePathJcrContent = contentBasePath + "/jcr:content"
        def pageContentNode = JcrUtils.getOrCreateByPath(contentBasePathJcrContent, "cq:Page", "cq:PageContent", itSession, false)
        pageContentNode.setProperty("sling:resourceType", "wcm/foundation/components/responsivegrid")
    
        for(int componentNo=1; componentNo<= componentsOnTestPage; componentNo++) {
            String compNoPadded = StringUtils.leftPad(componentNo+"", noPaddingWidth, "0")
            String ilNoPadded = StringUtils.leftPad(inheritanceLevel+"", noPaddingWidth, "0")
            String componentName = "comp"+compNoPadded+"inheritancelevel"+ilNoPadded
            String componentBasePath = appsBasePath + "/component"+compNoPadded
            String componentPath = componentBasePath+"/"+componentName
            String resourceSuperType = componentBasePath+"/comp"+compNoPadded+"inheritancelevel"+StringUtils.leftPad((inheritanceLevel-1)+"", noPaddingWidth, "0")
            String componentMainFile = componentName+".html"
            String sectionId = "section"+compNoPadded+"inheritancelevel"+ilNoPadded
            String sectionFile = sectionId+".html"
            
            if(!itSession.nodeExists(componentPath)) {
                def compFolder = JcrUtils.getOrCreateByPath(componentPath, "nt:folder", "cq:Component", itSession, false)
                if(inheritanceLevel > 1) {
                    compFolder.setProperty("sling:resourceSuperType", resourceSuperType.replace('/apps/',''))
                }
                String sectionFileContent = "    <p>"+sectionId+" \${properties.contentProp}</p>\n"
                JcrUtils.putFile(compFolder, sectionFile, "text/html", new ByteArrayInputStream(sectionFileContent.getBytes(StandardCharsets.UTF_8)))
                
                def includes = []
                for(int i=inheritanceLevel; i>0; i--) {
                    String iLevelIncludePadded = StringUtils.leftPad(i+"", noPaddingWidth, "0")
                    includes << "<div><sly data-sly-include=\"section"+compNoPadded+"inheritancelevel"+iLevelIncludePadded+".html\"></sly></div>"
                }
                
                String compFileContent = "<div>Component "+componentName+":\n"+StringUtils.join(includes, '\n')+"\n</div>\n\n\n"
                JcrUtils.putFile(compFolder, componentMainFile, "text/html", new ByteArrayInputStream(compFileContent.getBytes(StandardCharsets.UTF_8)))
            }
    
            def contentComponentPath = contentBasePathJcrContent + "/comp"+compNoPadded
            def contentComponentNode = JcrUtils.getOrCreateByPath(contentComponentPath, "nt:unstructured", "nt:unstructured", itSession, false)
            contentComponentNode.setProperty("sling:resourceType", componentPath.replace('/apps/',''))
            contentComponentNode.setProperty("contentProp", "Text from content "+compNoPadded)
        }    

    }

    itSession.save()
    breaklet.logOpFinished("Setup components for "+inheritanceLevelsPerIteration+ " more inheritance levels")

    def requestPath = contentBasePath+".html?wcmmode=disabled"
    def responseText = breaklet.performRequest(requestPath) 
    breaklet.logOpFinished("Request finished first request", responseText.length() + " chars received")

    responseText = breaklet.performRequest(requestPath) 
    breaklet.logOpFinished("Request finished second request", responseText.length() + " chars received")

    responseText = breaklet.performRequest(requestPath) 
    breaklet.logOpFinished("Request finished third request", responseText.length() + " chars received")

}


// DO NOT CHANGE BEYOND THIS POINT - master is https://gist.github.com/ghenzler/58ce57794ba9b5a60f2a2e60160be747 here

// --------------------------------------------------------------------
// Breaklet Base Utilities (to be copied at bottom of other breaklets)
// --------------------------------------------------------------------
import org.apache.jackrabbit.commons.JcrUtils
import org.apache.commons.lang3.StringUtils
import java.util.concurrent.ThreadLocalRandom
import javax.jcr.query.*
import org.apache.sling.jcr.api.*
import org.apache.sling.api.resource.observation.*
import java.util.Properties
import java.io.ByteArrayInputStream
import java.nio.charset.StandardCharsets
import org.osgi.service.event.EventConstants
import org.osgi.service.event.EventHandler
import org.osgi.service.event.Event
import org.apache.commons.io.IOUtils 
import org.apache.sling.hc.util.FormattingResultLog

class BreakletBrokeException extends RuntimeException { 
    String opName
    String timeSpent
    BreakletBrokeException(opName, timeSpent) { 
        this.opName = opName
        this.timeSpent = timeSpent 
    }
}
class BreakletPanicException extends RuntimeException { }

class Breaklet {

    int iterations
    int breakForDurationInSec
    String user
    String password
    
    long lastTimestamp = System.currentTimeMillis()
    def script
    long currentIteration
    String currentItLogMarker     
    
    Map<String,List> timings = new LinkedHashMap<String,List>()     

    Browser browser
    
    def resourceChangeListener = null
    def resourceChangeListenerReg = null
    def resourceChangeListenerPath = null
    
    def resourceChangeEventHandler = null
    def resourceChangeEventHandlerReg = null
    def resourceChangeEventHandlerPath = null
    
    Breaklet(def script, int breakForDurationInSec, String user=null, String password=null, int iterations=Integer.MAX_VALUE) {
        this.script = script
        this.breakForDurationInSec = breakForDurationInSec
        this.user = user
        this.password = password
        this.iterations = iterations
        
        this.browser = new Browser(script, breakForDurationInSec, user, password)
    }

    def logOpFinished(String opName, String opDescription="", def timeSpentMillis=null, def neverBreak=false) {
        script.logMsg(StringUtils.leftPad(currentItLogMarker, 7)+" " + StringUtils.rightPad(getTimeSpent(opName, timeSpentMillis as Long, neverBreak) + ":", 8) + " "+opName + " "+opDescription)
        currentItLogMarker = "" 
    }
    
    def getTimeSpent(String opName, Long timeSpentMillis=null, def neverBreak=false) {
        long delta = timeSpentMillis ?: System.currentTimeMillis()-lastTimestamp
        
        def timingSeriesForOp = timings.get(opName)
        if(timingSeriesForOp==null) { timings.put(opName, (timingSeriesForOp = new ArrayList<Long>())) }
        while(timingSeriesForOp.size() < currentIteration-1) { timingSeriesForOp.add(timingSeriesForOp.size(), '') }
        timingSeriesForOp.add((int)currentIteration-1, delta)

        String timeSpent = FormattingResultLog.msHumanReadable(delta)
        if((delta/1000) > breakForDurationInSec && !neverBreak) {
            throw new BreakletBrokeException(opName, timeSpent)
        }
        
        lastTimestamp = System.currentTimeMillis()
        return timeSpent
    }
    
    def run(toRun) {
        File currentWorkingDir = new File(System.getProperty('user.dir'))
        File panicFile = new File(currentWorkingDir, 'panic')
        
        try {
            (1..iterations).each { itNo ->
                currentItLogMarker = itNo+":"
                
                def sessionForIteration = null                
                try {
                    if(StringUtils.isNotBlank(user)) {
                        sessionForIteration = getSessionFor(user, password)
                    }
                    currentIteration = itNo
                    def sessionForIt = sessionForIteration ?: script.session
                    toRun(this, currentIteration, sessionForIt)
                    
                    if(panicFile.exists()) {
                        panicFile.renameTo(new File(currentWorkingDir, 'no-panic'))
                        throw new BreakletPanicException()
                    }                    

                } finally {
                    if(sessionForIteration!=null && sessionForIteration.isLive()) {
                        sessionForIteration.logout()
                    }
                }
            }         
            script.logMsg("\n\nBreaklet survived - "+iterations+" iterations finished without exceeding the threshold\n")
        } catch(BreakletBrokeException e) {
            script.logMsg("\n\nBreaklet broke at iteration "+currentIteration+": Operation '"+e.opName+"' "+e.timeSpent + " >= "+breakForDurationInSec + "sec\n")
        } catch(BreakletPanicException e) {
            script.logMsg("\nBreaklet broke due to panic after iteration "+currentIteration+"\n")
        } catch(Exception e) {
            script.logMsg("\n\nBreaklet broke at iteration "+currentIteration+" with unexpected exception: "+e)
            script.log.info("Exception:"+e, e)
        } finally {
            String result = ""
            timings.keySet().each { key ->
                result += ""+key+","+ StringUtils.join(timings.get(key),',') + "\n"
            }
            new File(currentWorkingDir, 'breaklet-result-'+new Date().getTime()+'.csv').text = result
            
            if(resourceChangeListenerReg) {
                resourceChangeListenerReg.unregister()
            }
            if(resourceChangeEventHandlerReg) {
                resourceChangeEventHandlerReg.unregister()
            }
        }

    } 
    
    def runInBrowser(String puppeteerScript) {
        return browser.run(puppeteerScript)
    }

    def getSessionFor(sessionUser, sessionPassword) {
      def repository = script.session.getRepository()
      def session = repository.login(new SimpleCredentials(sessionUser, sessionPassword.toCharArray()));
      return session
    }

    def registerResourceChangeListener(paths) {
        resourceChangeListenerPath = paths
        resourceChangeListener = new ResourceChangeListener() {
            int changesReceived = 0
            int callsReceived = 0
            def allChanges = []
            public void onChange(List<ResourceChange> changes) {
                changesReceived += changes.size()
                callsReceived++
                allChanges.addAll(changes)
            }
            public void reset() {
                changesReceived = 0
                callsReceived = 0
                allChanges = []
            }
        }
        resourceChangeListenerReg = script.bundleContext.registerService("org.apache.sling.api.resource.observation.ResourceChangeListener", resourceChangeListener, new Hashtable([(ResourceChangeListener.PATHS): paths]))
        return resourceChangeListener
    }

    def registerResourceChangeEventHandler(path) {
        resourceChangeEventHandlerPath = path
        resourceChangeEventHandler = new EventHandler() {
            int eventsReceived = 0
            def allEvents = []
            public void handleEvent(final Event event) {
                eventsReceived++
                allEvents.addAll(event)
            }
            public void reset() {
                eventsReceived = 0
                allEvents = []
            }            
        }
        resourceChangeEventHandlerReg = script.bundleContext.registerService("org.osgi.service.event.EventHandler", resourceChangeEventHandler, 
        new Hashtable([
            (EventConstants.EVENT_TOPIC): "org/apache/sling/api/resource/Resource/*",
            (EventConstants.EVENT_FILTER): "("+SlingConstants.PROPERTY_PATH+"="+path+"*)",
            ]))
        return resourceChangeEventHandler
    }

    def waitForResourceChangedEvents(long minimumExpectedChanges, long maxWaitInSec=300, String opName=null) { 
        boolean timeout = false
        
        int waitCounter = 0
        while((resourceChangeListener && resourceChangeListener.changesReceived < minimumExpectedChanges)
              || (resourceChangeEventHandler && resourceChangeEventHandler.eventsReceived < minimumExpectedChanges)
            ) {
            if((lastTimestamp + maxWaitInSec*1000) < System.currentTimeMillis()) {
                timeout = true
                break
            }
            Thread.sleep(50)
        }

        String resourceChangeListenerResult = resourceChangeListener ? " changesReceived="+resourceChangeListener.changesReceived+" (in "+resourceChangeListener.callsReceived +" calls) " : ""
        String resourceChangeEventHandlerResult = resourceChangeEventHandler ? " eventsReceived="+resourceChangeEventHandler.eventsReceived : ""
        opName = opName ?: "Wait for resource changed events ("+(resourceChangeListenerPath?:resourceChangeEventHandlerPath)+")"
        logOpFinished(opName, (timeout?'Timed out after '+maxWaitInSec+'sec ':'') + resourceChangeListenerResult + resourceChangeEventHandlerResult)
        
        resourceChangeListener?.reset()
        resourceChangeEventHandler?.reset()
    }
    
    def performRequest(String requestPath, String reqUser=user, String reqPassword=password) {
        def con = new URL(script.getBaseUrl()+requestPath).openConnection();
        String encoded = Base64.getEncoder().encodeToString((reqUser+":"+reqPassword).getBytes(StandardCharsets.UTF_8)); 
        con.setRequestProperty("Authorization", "Basic "+encoded);
        def result = IOUtils.toString(con.getInputStream());
        return result     
    }    

}

class Browser {
    
    // config
    def script
    String user
    String password
    int breakForDurationInSec
    
    // state
    File browserDir
    String testJsTemplate
    Properties resultProps

    Browser(def script, int breakForDurationInSec, String user, String password) {
        this.script = script
        this.breakForDurationInSec = breakForDurationInSec
        this.user = user
        this.password = password
    }

    def init() {
        browserDir = new File(System.getProperty('user.dir')+'/puppeteer')
        if(!browserDir.exists()) {
            script.logMsg("init "+ browserDir)
            browserDir.mkdir()
            new File(browserDir, 'package.json').text = """                
                {
                  "name": "puppeteer-breaklet",
                  "version": "1.0.0",
                  "scripts": {
                    "test": "node test.js"
                  },
                  "dependencies": {
                    "puppeteer": "1.7.0"
                  }
                }
                """.stripIndent()
            def result = script.exec("npm install", browserDir)
            script.logMsg("npm install result: "+ result)
        } 
        testJsTemplate = '''                
            const puppeteer = require('puppeteer');
            
            let baseUrl = process.argv[2]
            let user = process.argv[3]
            let password = process.argv[4]
            let startTime = process.argv[5]
            let defaultTimeout = 120*1000
            let screenshotCreated = false
            
            let loginPage = "/libs/granite/core/content/login.html"
            
            function sleep(ms) {
              return new Promise(resolve => setTimeout(resolve, ms));
            }
            
            function getCrxdeXPath(nodeName) {
                return "//*[@id='repository']//a[span/text()='"+nodeName+"']"
            }
            
            async function waitForXPath(page, xpath) {
                await page.waitForXPath(xpath, { timeout: defaultTimeout})    
                let nodeElements = await page.$x(xpath)
                return nodeElements[0]
            }
            
            async function waitForCrxdeNodeWithName(page, nodeName) {
                let nodeElXPath = getCrxdeXPath(nodeName)
                return await waitForXPath(page, nodeElXPath)
            }
            
            async function waitForAndClick(page, selector, retry=true) {
            
                await page.waitForSelector(selector, { timeout: defaultTimeout, visible: true})   
                
                if (await page.$(selector) === null) {
                    throw new Error("Could not find " + selector + " even after waiting for " + defaultTimeout);
                }
                
                try {
                    await page.click(selector)
                } catch(err) {
                    if(retry) {
                        console.log("Error " +err+" while clicking on selector "+selector+", retrying...") 
                        await sleep(200)
                        waitForAndClick(page, selector, false);
                    } else {
                        throw err
                    }
                }
            }
            
            async function clickOnIconOfCrxdeNode(page, nodeHandle) {
                await page.evaluate(node => node.previousSibling.previousSibling.click(), nodeHandle);
            }
            
            async function createScreenshot(page, name=null) {
                if(page) {
                    await page.screenshot({path: 'run-'+startMillis+(name ? '-'+name : '')+'.png'});
                    screenshotCreated = true
                }
            }

            async function run() {
             var resultProps = {};
             const browser = await puppeteer.launch({headless: true, dumpio: true, args: ['--window-size=1440,900', "--no-sandbox"]});
             let page = null
             try {
                //const context = await browser.createIncognitoBrowserContext();
                page = await browser.newPage(); //  context or browser
                await page.setViewport({width: 1440, height: 900});
            
                await page.goto(baseUrl + loginPage);  
                await page.$eval('#username', (el, pUsername) => el.value = pUsername, user);
                await page.$eval('#password', (el, pPassword) => el.value = pPassword, password);
                await sleep(500);
                await page.$eval('#login', form => form.submit());
                await page.waitForNavigation({ waitUntil: 'networkidle0'})
                if(new RegExp('.*?'+loginPage+'.*').test(await page.url())) {
                    throw new Error("Could not login!");
                } else {
                    console.log("Logged in user "+user)
                }
                
                startMillis = new Date().getTime()
                console.log("Starting user script at start milliseconds =", startMillis)        
            
                %SCRIPT% 
                
              } catch(err) {
                console.log("Error during execution: ", err)
              } finally {
                if(!screenshotCreated) {
                    await createScreenshot(page)
                }
                browser.close();
                let delta = new Date().getTime()-startMillis
                console.log("----------------")
                for (let key in resultProps) {
                    console.log(key+"="+resultProps[key])    
                }
                console.log("browserDurationInMillis="+delta)
              }  
            }
            run();
            '''.stripIndent()

    }

    def run(String scriptToRun) {
        init()
        new File(browserDir, 'test.js').text = testJsTemplate.replace('%SCRIPT%', scriptToRun)
        def baseUrl = script.getBaseUrl()
        def startTime = System.currentTimeMillis()
        def cmd = "npm test $baseUrl $user $password $startTime"
        def scriptResult = script.exec(cmd, browserDir, breakForDurationInSec)
        new File(browserDir, 'run-'+new Date().getTime()+".log").text = scriptResult
        if(scriptResult.contains("Error during execution:")) {
            throw new IllegalStateException("Browser execution failed")
        }
        def propsString = StringUtils.substringAfter(scriptResult, "----------------\n")
        resultProps = new Properties()
        resultProps.load(new ByteArrayInputStream(propsString.getBytes(StandardCharsets.UTF_8)))
        long browserDurationInMillis = resultProps.containsKey('breakForDurationInSec') ? Long.parseLong(resultProps.getProperty('breakForDurationInSec')) : (System.currentTimeMillis()-startTime) 
        return browserDurationInMillis
    }    
    
}

def logMsg(String msg) {
    log.info(msg)
    println(msg)
}

def getBaseUrl() {
    def aemPort = System.getProperty('sun.java.command').replaceFirst(".*?-p ([0-9]+) .*", "\$1")
    return "http://localhost:"+aemPort
} 

import org.apache.commons.exec.CommandLine
import org.apache.commons.exec.DefaultExecutor
import org.apache.commons.exec.PumpStreamHandler
import org.apache.commons.exec.ExecuteWatchdog

def exec(String command, File dir, int breakForDurationInSec=600) {
    CommandLine cmdLine = CommandLine.parse(command);
    DefaultExecutor executor = new DefaultExecutor();
    executor.setWorkingDirectory(dir)
    
    ExecuteWatchdog watchdog = new ExecuteWatchdog(breakForDurationInSec * 1000);
    executor.setWatchdog(watchdog);    
    
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    PumpStreamHandler streamHandler = new PumpStreamHandler(outputStream);
    executor.setStreamHandler(streamHandler);
    executor.setExitValues([0,1,143] as int[])
    int exitValue = executor.execute(cmdLine);  
    String scriptOutput = outputStream.toString()
    if(exitValue == 1) {
        logMsg("Script '"+command+"' returned exit code 1, output:\n "+ scriptOutput)
    }
    return scriptOutput
}