Ok, this isn't even a question:
import com.gargoylesoftware.htmlunit.HttpMethod
import com.gargoylesoftware.htmlunit.WebClient
import com.gargoylesoftware.htmlunit.WebResponseData
import com.gargoylesoftware.htmlunit.WebResponseImpl
import com.gargoylesoftware.htmlunit.util.Cookie
import com.gargoylesoftware.htmlunit.util.NameValuePair
import static groovyx.net.http.ContentType.TEXT
import java.io.File
import java.util.logging.Logger
import org.apache.http.impl.cookie.BasicClientCookie
/**
* HTTPBuilder class
*
* Allows Javascript processing using HTMLUnit
*
* @author Misha Koshelev
*/
class HTTPBuilder {
/**
* HTTP Builder - implement this way to avoid underlying logging output
*/
def httpBuilder
/**
* Logger
*/
def logger
/**
* Directory for storing HTML files, if any
*/
def saveDirectory=null
/**
* Index of current HTML file in directory
*/
def saveIdx=1
/**
* Current page text
*/
def text=null
/**
* Response for processJavascript (Complex Version)
*/
def resp=null
/**
* URI for processJavascript (Complex Version)
*/
def uri=null
/**
* HttpMethod for processJavascript (Complex Version)
*/
def method=null
/**
* Default constructor
*/
public HTTPBuilder() {
// New HTTPBuilder
httpBuilder=new groovyx.net.http.HTTPBuilder()
// Logging
logger=Logger.getLogger(this.class.name)
}
/**
* Constructor that allows saving output files for testing
*/
public HTTPBuilder(saveDirectory,saveIdx) {
this()
this.saveDirectory=saveDirectory
this.saveIdx=saveIdx
}
/**
* Save text and return corresponding XmlSlurper object
*/
public saveText() {
if (saveDirectory) {
def file=new File(saveDirectory.toString()+File.separator+saveIdx+".html")
logger.finest "HTTPBuilder.saveText: file=\""+file.toString()+"\""
file<<text
saveIdx++
}
new XmlSlurper(new org.cyberneko.html.parsers.SAXParser()).parseText(text)
}
/**
* Wrapper around supertype get method
*/
public Object get(Map<String,?> args) {
logger.finer "HTTPBuilder.get: args=\""+args+"\""
args.contentType=TEXT
httpBuilder.get(args) { resp,reader->
text=reader.text
this.resp=resp
this.uri=args.uri
this.method=HttpMethod.GET
saveText()
}
}
/**
* Wrapper around supertype post method
*/
public Object post(Map<String,?> args) {
logger.finer "HTTPBuilder.post: args=\""+args+"\""
args.contentType=TEXT
httpBuilder.post(args) { resp,reader->
text=reader.text
this.resp=resp
this.uri=args.uri
this.method=HttpMethod.POST
saveText()
}
}
/**
* Load cookies from specified file
*/
def loadCookies(file) {
logger.finer "HTTPBuilder.loadCookies: file=\""+file.toString()+"\""
file.withObjectInputStream { ois->
ois.readObject().each { cookieMap->
def cookie=new BasicClientCookie(cookieMap.name,cookieMap.value)
cookieMap.remove("name")
cookieMap.remove("value")
cookieMap.entrySet().each { entry->
cookie."${entry.key}"=entry.value
}
httpBuilder.client.cookieStore.addCookie(cookie)
}
}
}
/**
* Save cookies to specified file
*/
def saveCookies(file) {
logger.finer "HTTPBuilder.saveCookies: file=\""+file.toString()+"\""
def cookieMaps=new ArrayList(new LinkedHashMap())
httpBuilder.client.cookieStore.getCookies().each { cookie->
def cookieMap=[:]
cookieMap.version=cookie.version
cookieMap.name=cookie.name
cookieMap.value=cookie.value
cookieMap.domain=cookie.domain
cookieMap.path=cookie.path
cookieMap.expiryDate=cookie.expiryDate
cookieMaps.add(cookieMap)
}
file.withObjectOutputStream { oos->
oos.writeObject(cookieMaps)
}
}
/**
* Process Javascript using HTMLUnit (Simple Version)
*/
def processJavascript() {
logger.finer "HTTPBuilder.processJavascript (Simple)"
def webClient=new WebClient()
def tempFile=File.createTempFile("HTMLUnit","")
tempFile<<text
def page=webClient.getPage("file://"+tempFile.toString())
webClient.waitForBackgroundJavaScript(10000)
text=page.asXml()
webClient.closeAllWindows()
tempFile.delete()
saveText()
}
/**
* Process Javascript using HTMLUnit (Complex Version)
* Closure, if specified, used to determine presence of necessary elements
*/
def processJavascript(closure) {
logger.finer "HTTPBuilder.processJavascript (Complex)"
// Convert response headers
def headers=new ArrayList()
resp.allHeaders.each() { header->
headers.add(new NameValuePair(header.name,header.value))
}
def responseData=new WebResponseData(text.bytes,resp.statusLine.statusCode,resp.statusLine.toString(),headers)
def response=new WebResponseImpl(responseData,uri.toURL(),method,0)
// Transfer cookies
def webClient=new WebClient()
httpBuilder.client.cookieStore.getCookies().each { cookie->
webClient.cookieManager.addCookie(new Cookie(cookie.domain,cookie.name,cookie.value,cookie.path,cookie.expiryDate,cookie.isSecure()))
}
def page=webClient.loadWebResponseInto(response,webClient.getCurrentWindow())
// Wait for condition
if (closure) {
for (i in 1..20) {
if (closure(page)) {
break;
}
synchronized(page) {
page.wait(500);
}
}
}
// Return text
text=page.asXml()
webClient.closeAllWindows()
saveText()
}
}
Allows one to interface HTTPBuilder with HTMLUnit! Enjoy
Misha
