def __init__(self, params, username = None, password = None):
"""
Builds an HttpRequest
:param params: an <a href="/jython-docs/#!/_PROD_VERSION_/service/com.xebialabs.xlrelease.domain.configuration.HttpConnection">HttpConnection</a>
:param username: the username
(optional, it will override the credentials defined on the <a href="/jython-docs/#!/_PROD_VERSION_/service/com.xebialabs.xlrelease.domain.configuration.HttpConnection">HttpConnection</a> object)
:param password: an password
(optional, it will override the credentials defined on the <a href="/jython-docs/#!/_PROD_VERSION_/service/com.xebialabs.xlrelease.domain.configuration.HttpConnection">HttpConnection</a> object)
"""
self.params = HttpConnection(params)
self.username = username
self.password = password
def __init__(self, params, username = None, password = None, verify = True):
"""
Builds an HttpRequest
:param username: the username for basic authentication
(optional, no authentication will be used if empty)
:param password: an password
(optional)
"""
self.params = HttpConnection(params)
self.username = username
self.password = password
self.verify = verify
def __init__(self, params, username=None, password=None):
"""
Builds an HttpRequest
:param params: an HttpConnection
:param username: the username
(optional, it will override the credentials defined on the HttpConnection object)
:param password: an password
(optional, it will override the credentials defined on the HttpConnection object)
"""
self.params = HttpConnection(params)
self.username = username
self.password = password
class QtestHTTPRequest(HttpRequest):
def __init__(self, params, username=None, password=None, token=None):
self.params = HttpConnection(params)
self.username = username
self.password = password
self.token = token
def setCredentials(self, request):
if self.token:
request.addHeader('Authorization', self.token)
return
elif self.username:
username = self.username
elif self.params.getUsername():
username = self.params.getUsername()
else:
return
encoding = Base64.encodeBase64String(
String(username + ':').getBytes('ISO-8859-1'))
request.addHeader('Authorization', 'Basic ' + encoding)
def buildRequest(self, method, context, body, contentType, headers):
url = self.quote(self.createPath(self.params.getUrl(), context))
method = method.upper()
if method == 'GET':
request = HttpGet(url)
elif method == 'HEAD':
request = HttpHead(url)
elif method == 'POST':
request = HttpPost(url)
request.setEntity(StringEntity(body))
elif method == 'PUT':
request = HttpPut(url)
request.setEntity(StringEntity(body))
elif method == 'DELETE':
request = HttpDelete(url)
elif method == 'PATCH':
request = HttpPatch(url)
request.setEntity(StringEntity(body))
else:
raise Exception('Unsupported method: ' + method)
request.addHeader('Content-Type', contentType)
self.setCredentials(request)
self.setProxy(request)
self.setHeaders(request, headers)
return request
def __init__(self, params, username=None, password=None, verify=True):
"""
Builds an HttpRequest
:param username: the username for basic authentication
(optional, no authentication will be used if empty)
:param password: an password
(optional)
"""
self.params = HttpConnection(params)
self.username = username
self.password = password
self.verify = verify
self.logger = LoggerFactory.getLogger(
"com.xebialabs.dockerregistryv2-plugin")
def __init__(self, params, username=None, password=None, domain=None):
"""
Builds an HttpRequest
:param params: an HttpConnection
:param username: the username
(optional, it will override the credentials defined on the HttpConnection object)
:param password: an password
(optional, it will override the credentials defined on the HttpConnection object)
"""
self.params = HttpConnection(params)
self.shared_domain = params['domain']
self.username = username
self.password = password
self.domain = domain
self.authentication = params['authenticationMethod']
def __init__(self, params, username=None, password=None):
"""
Builds an HttpRequest
:param params: an HttpConnection
:param username: the username
(optional, it will override the credentials defined on the HttpConnection object)
:param password: an password
(optional, it will override the credentials defined on the HttpConnection object)
"""
self.params = HttpConnection(params)
self.username = username
self.password = password
def __init__(self, params, username=None, password=None, token=None):
self.params = HttpConnection(params)
self.username = username
self.password = password
self.token = token
class HttpRequest:
def __init__(self, params, username = None, password = None, verify = True):
"""
Builds an HttpRequest
:param username: the username for basic authentication
(optional, no authentication will be used if empty)
:param password: an password
(optional)
"""
self.params = HttpConnection(params)
self.username = username
self.password = password
self.verify = verify
def doRequest(self, **options):
"""
Performs an HTTP Request
:param options: A keyword arguments object with the following properties :
method: the HTTP method : 'GET', 'PUT', 'POST', 'DELETE', 'PATCH'
(optional: GET will be used if empty)
context: the context url
(optional: the url on <a href="/jython-docs/#!/_PROD_VERSION_/service/com.xebialabs.xlrelease.domain.configuration.HttpConnection">HttpConnection</a> will be used if empty)
body: the body of the HTTP request for PUT & POST calls
(optional: an empty body will be used if empty)
contentType: the content type to use
(optional, no content type will be used if empty)
headers: a dictionary of headers key/values
(optional, no headers will be used if empty)
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
request = self.buildRequest(
options.get('method', 'GET'),
options.get('context', ''),
options.get('body', ''),
options.get('contentType', None),
options.get('headers', None))
return self.executeRequest(request)
def get(self, context, **options):
"""
Performs an HTTP GET Request
:param context: the context url
:param options: the options keyword argument described in doRequest()
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
options['method'] = 'GET'
options['context'] = context
return self.doRequest(**options)
def head(self, context, **options):
"""
Performs an HTTP HEAD Request
:param context: the context url
:param options: the options keyword argument described in doRequest()
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
options['method'] = 'HEAD'
options['context'] = context
return self.doRequest(**options)
def put(self, context, body, **options):
"""
Performs an HTTP PUT Request
:param context: the context url
:param body: the body of the HTTP request
:param options: the options keyword argument described in doRequest()
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
options['method'] = 'PUT'
options['context'] = context
options['body'] = body
return self.doRequest(**options)
def post(self, context, body, **options):
"""
Performs an HTTP POST Request
:param context: the context url
:param body: the body of the HTTP request
:param options: the options keyword argument described in doRequest()
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
options['method'] = 'POST'
options['context'] = context
options['body'] = body
return self.doRequest(**options)
def delete(self, context, **options):
"""
Performs an HTTP DELETE Request
:param context: the context url
:param options: the options keyword argument described in doRequest()
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
options['method'] = 'DELETE'
options['context'] = context
return self.doRequest(**options)
def patch(self, context, body, **options):
"""
Performs an HTTP PATCH Request
:param context: the context url
:param body: the body of the HTTP request
:param options: the options keyword argument described in doRequest()
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
options['method'] = 'PATCH'
options['context'] = context
options['body'] = body
return self.doRequest(**options)
def buildRequest(self, method, context, body, contentType, headers):
url = self.quote(self.createPath(self.params.getUrl(), context))
method = method.upper()
if method == 'GET':
request = HttpGet(url)
elif method == 'HEAD':
request = HttpHead(url)
elif method == 'POST':
request = HttpPost(url)
request.setEntity(StringEntity(body))
elif method == 'PUT':
request = HttpPut(url)
request.setEntity(StringEntity(body))
elif method == 'DELETE':
request = HttpDelete(url)
elif method == 'PATCH':
request = HttpPatch(url)
request.setEntity(StringEntity(body))
else:
raise Exception('Unsupported method: ' + method)
request.addHeader('Content-Type', contentType)
request.addHeader('Accept', contentType)
self.setCredentials(request)
self.setProxy(request)
self.setHeaders(request, headers)
return request
def createPath(self, url, context):
url = re.sub('/*$', '', url)
if context is None:
return url
elif context.startswith('/'):
return url + context
else:
return url + '/' + context
def quote(self, url):
return urllib.quote(url, ':/?&=%')
def setCredentials(self, request):
if self.username:
username = self.username
password = self.password
elif self.params.getUsername():
username = self.params.getUsername()
password = self.params.getPassword()
else:
return
encoding = Base64.encodeBase64String(String(username + ':' + password).getBytes('ISO-8859-1'))
request.addHeader('Authorization', 'Basic ' + encoding)
def setProxy(self, request):
if not self.params.getProxyHost():
return
proxy = HttpHost(self.params.getProxyHost(), int(self.params.getProxyPort()))
config = RequestConfig.custom().setProxy(proxy).build()
request.setConfig(config)
def setHeaders(self, request, headers):
if headers:
for key in headers:
request.setHeader(key, headers[key])
def executeRequest(self, request):
client = None
response = None
try:
if not self.verify:
client = self.create_http_client()
elif self.params.proxyUsername and self.params.proxyPassword:
credentials = UsernamePasswordCredentials(self.params.proxyUsername, self.params.proxyPassword)
auth_scope = AuthScope(self.params.proxyHost, Integer.valueOf(self.params.proxyPort))
creds_provider = BasicCredentialsProvider()
creds_provider.setCredentials(auth_scope, credentials)
client = HttpClientBuilder.create().setDefaultCredentialsProvider(creds_provider).build()
else:
client = HttpClients.createDefault()
response = client.execute(request)
status = response.getStatusLine().getStatusCode()
entity = response.getEntity()
result = EntityUtils.toString(entity, "UTF-8") if entity else None
headers = response.getAllHeaders()
EntityUtils.consume(entity)
return HttpResponse(status, result, headers)
finally:
if response:
response.close()
if client:
client.close()
def create_http_client(self):
builder = SSLContextBuilder()
builder.loadTrustMaterial(None, TrustAllStrategy())
tls_versions = ["TLSv1", "TLSv1.1", "TLSv1.2"]
socketfactory = SSLConnectionSocketFactory(builder.build(), tls_versions, None, SSLConnectionSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER)
# print 'DEBUG: Created custom HttpClient to trust all certs\n'
return HttpClients.custom().setSSLSocketFactory(socketfactory).build()
class HttpRequest:
def __init__(self, params, username=None, password=None):
"""
Builds an HttpRequest
:param params: an HttpConnection
:param username: the username
(optional, it will override the credentials defined on the HttpConnection object)
:param password: an password
(optional, it will override the credentials defined on the HttpConnection object)
"""
self.params = HttpConnection(params)
self.username = username
self.password = password
def doRequest(self, **options):
"""
Performs an HTTP Request
:param options: A keyword arguments object with the following properties :
method: the HTTP method : 'GET', 'PUT', 'POST', 'DELETE', 'PATCH'
(optional: GET will be used if empty)
context: the context url
(optional: the url on HttpConnection will be used if empty)
body: the body of the HTTP request for PUT & POST calls
(optional: an empty body will be used if empty)
contentType: the content type to use
(optional, no content type will be used if empty)
headers: a dictionary of headers key/values
(optional, no headers will be used if empty)
:return: an HttpResponse instance
"""
request = self.buildRequest(options.get('method', 'GET'),
options.get('context', ''),
options.get('body', ''),
options.get('contentType', None),
options.get('headers', None))
return self.executeRequest(request)
def get(self, context, **options):
"""
Performs an Http GET Request
:param context: the context url
:param options: the options keyword argument described in doRequest()
:return: an HttpResponse instance
"""
options['method'] = 'GET'
options['context'] = context
return self.doRequest(**options)
def put(self, context, body, **options):
"""
Performs an Http PUT Request
:param context: the context url
:param body: the body of the HTTP request
:param options: the options keyword argument described in doRequest()
:return: an HttpResponse instance
"""
options['method'] = 'PUT'
options['context'] = context
options['body'] = body
return self.doRequest(**options)
def post(self, context, body, **options):
"""
Performs an Http POST Request
:param context: the context url
:param body: the body of the HTTP request
:param options: the options keyword argument described in doRequest()
:return: an HttpResponse instance
"""
options['method'] = 'POST'
options['context'] = context
options['body'] = body
return self.doRequest(**options)
def delete(self, context, **options):
"""
Performs an Http DELETE Request
:param context: the context url
:param options: the options keyword argument described in doRequest()
:return: an HttpResponse instance
"""
options['method'] = 'DELETE'
options['context'] = context
return self.doRequest(**options)
def patch(self, context, body, **options):
"""
Performs an Http PATCH Request
:param context: the context url
:param body: the body of the HTTP request
:param options: the options keyword argument described in doRequest()
:return: an HttpResponse instance
"""
options['method'] = 'PATCH'
options['context'] = context
options['body'] = body
return self.doRequest(**options)
def buildRequest(self, method, context, body, contentType, headers):
url = self.quote(self.createPath(self.params.getUrl(), context))
method = method.upper()
if method == 'GET':
request = HttpGet(url)
elif method == 'POST':
request = HttpPost(url)
request.setEntity(StringEntity(body))
elif method == 'PUT':
request = HttpPut(url)
request.setEntity(StringEntity(body))
elif method == 'DELETE':
request = HttpDelete(url)
elif method == 'PATCH':
request = HttpPatch(url)
request.setEntity(StringEntity(body))
else:
raise Exception('Unsupported method: ' + method)
request.addHeader('Content-Type', contentType)
request.addHeader('Accept', contentType)
self.setCredentials(request)
self.setProxy(request)
self.setHeaders(request, headers)
return request
def createPath(self, url, context):
url = re.sub('/*$', '', url)
if context is None:
return url
elif context.startswith('/'):
return url + context
else:
return url + '/' + context
def quote(self, url):
return urllib.quote(url, ':/?&=%')
def setCredentials(self, request):
if self.username:
username = self.username
password = self.password
elif self.params.getUsername():
username = self.params.getUsername()
password = self.params.getPassword()
else:
return
encoding = Base64.encodeBase64String(
String(username + ':' + password).getBytes('ISO-8859-1'))
request.addHeader('Authorization', 'Basic ' + encoding)
def setProxy(self, request):
if not self.params.getProxyHost():
return
proxy = HttpHost(self.params.getProxyHost(),
int(self.params.getProxyPort()))
config = RequestConfig.custom().setProxy(proxy).build()
request.setConfig(config)
def setHeaders(self, request, headers):
if headers:
for key in headers:
request.setHeader(key, headers[key])
def executeRequest(self, request):
client = None
response = None
try:
client = HttpClients.createDefault()
response = client.execute(request)
status = response.getStatusLine().getStatusCode()
entity = response.getEntity()
result = EntityUtils.toString(entity, "UTF-8") if entity else None
headers = response.getAllHeaders()
EntityUtils.consume(entity)
return HttpResponse(status, result, headers)
finally:
if response:
response.close()
if client:
client.close()
class HttpRequest:
def __init__(self, params, username=None, password=None):
"""
Builds an HttpRequest
:param params: an HttpConnection
:param username: the username
(optional, it will override the credentials defined on the HttpConnection object)
:param password: an password
(optional, it will override the credentials defined on the HttpConnection object)
"""
self.params = HttpConnection(params)
self.username = username
self.password = password
def doRequest(self, **options):
"""
Performs an HTTP Request
:param options: A keyword arguments object with the following properties :
method: the HTTP method : 'GET', 'PUT', 'POST', 'DELETE'
(optional: GET will be used if empty)
context: the context url
(optional: the url on HttpConnection will be used if empty)
body: the body of the HTTP request for PUT & POST calls
(optional: an empty body will be used if empty)
contentType: the content type to use
(optional, no content type will be used if empty)
headers: a dictionary of headers key/values
(optional, no headers will be used if empty)
:return: an HttpResponse instance
"""
request = self.buildRequest(
options.get("method", "GET"),
options.get("context", ""),
options.get("body", ""),
options.get("contentType", None),
options.get("headers", None),
)
return self.executeRequest(request)
def get(self, context, **options):
"""
Performs an Http GET Request
:param context: the context url
:param options: the options keyword argument described in doRequest()
:return: an HttpResponse instance
"""
options["method"] = "GET"
options["context"] = context
return self.doRequest(**options)
def put(self, context, body, **options):
"""
Performs an Http PUT Request
:param context: the context url
:param body: the body of the HTTP request
:param options: the options keyword argument described in doRequest()
:return: an HttpResponse instance
"""
options["method"] = "PUT"
options["context"] = context
options["body"] = body
return self.doRequest(**options)
def post(self, context, body, **options):
"""
Performs an Http POST Request
:param context: the context url
:param body: the body of the HTTP request
:param options: the options keyword argument described in doRequest()
:return: an HttpResponse instance
"""
options["method"] = "POST"
options["context"] = context
options["body"] = body
return self.doRequest(**options)
def delete(self, context, **options):
"""
Performs an Http DELETE Request
:param context: the context url
:param options: the options keyword argument described in doRequest()
:return: an HttpResponse instance
"""
options["method"] = "DELETE"
options["context"] = context
return self.doRequest(**options)
def buildRequest(self, method, context, body, contentType, headers):
url = self.quote(self.createPath(self.params.getUrl(), context))
method = method.upper()
if method == "GET":
request = HttpGet(url)
elif method == "POST":
request = HttpPost(url)
request.setEntity(StringEntity(body))
elif method == "PUT":
request = HttpPut(url)
request.setEntity(StringEntity(body))
elif method == "DELETE":
request = HttpDelete(url)
else:
raise Exception("Unsupported method: " + method)
request.addHeader("Content-Type", contentType)
request.addHeader("Accept", contentType)
self.setCredentials(request)
self.setProxy(request)
self.setHeaders(request, headers)
return request
def createPath(self, url, context):
url = re.sub("/*$", "", url)
if context is None:
return url
elif context.startswith("/"):
return url + context
else:
return url + "/" + context
def quote(self, url):
return urllib.quote(url, ":/?&=%")
def setCredentials(self, request):
if self.username:
username = self.username
password = self.password
elif self.params.getUsername():
username = self.params.getUsername()
password = self.params.getPassword()
else:
return
encoding = Base64.encodeBase64String(String(username + ":" + password).getBytes())
request.addHeader("Authorization", "Basic " + encoding)
def setProxy(self, request):
if not self.params.getProxyHost():
return
proxy = HttpHost(self.params.getProxyHost(), int(self.params.getProxyPort()))
config = RequestConfig.custom().setProxy(proxy).build()
request.setConfig(config)
def setHeaders(self, request, headers):
if headers:
for key in headers:
request.setHeader(key, headers[key])
def executeRequest(self, request):
client = None
response = None
try:
client = HttpClients.createDefault()
response = client.execute(request)
status = response.getStatusLine().getStatusCode()
entity = response.getEntity()
result = EntityUtils.toString(entity, "UTF-8") if entity else None
headers = response.getAllHeaders()
EntityUtils.consume(entity)
return HttpResponse(status, result, headers)
finally:
if response:
response.close()
if client:
client.close()
class HttpRequestPlus:
logger = logging.getLogger('HttpRequestPlus')
def __init__(self, params, username=None, password=None):
"""
Builds an HttpRequest
:param params: an <a href="/jython-docs/#!/_PROD_VERSION_/service/com.xebialabs.xlrelease.domain.configuration.HttpConnection">HttpConnection</a>
:param username: the username
(optional, it will override the credentials defined on the <a href="/jython-docs/#!/_PROD_VERSION_/service/com.xebialabs.xlrelease.domain.configuration.HttpConnection">HttpConnection</a> object)
:param password: an password
(optional, it will override the credentials defined on the <a href="/jython-docs/#!/_PROD_VERSION_/service/com.xebialabs.xlrelease.domain.configuration.HttpConnection">HttpConnection</a> object)
"""
self.params = HttpConnection(params)
self.username = username
self.password = password
def doRequest(self, **options):
"""
Performs an HTTP Request
:param options: A keyword arguments object with the following properties :
method: the HTTP method : 'GET', 'PUT', 'POST', 'DELETE', 'PATCH'
(optional: GET will be used if empty)
context: the context url
(optional: the url on <a href="/jython-docs/#!/_PROD_VERSION_/service/com.xebialabs.xlrelease.domain.configuration.HttpConnection">HttpConnection</a> will be used if empty)
body: the body of the HTTP request for PUT & POST calls
(optional: an empty body will be used if empty)
contentType: the content type to use
(optional, no content type will be used if empty)
headers: a dictionary of headers key/values
(optional, no headers will be used if empty)
quotePlus: boolean to control quoting with urllib.quote_plus() versus urllib.quote()
(optional, urllib.quote() will be used if empty or false)
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
request = self.buildRequest(options.get('method', 'GET'),
options.get('context', ''),
options.get('body', ''),
options.get('contentType', None),
options.get('headers', None),
options.get('quotePlus', False))
return self.executeRequest(request)
def get(self, context, **options):
"""
Performs an HTTP GET Request
:param context: the context url
:param options: the options keyword argument described in doRequest()
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
options['method'] = 'GET'
options['context'] = context
return self.doRequest(**options)
def head(self, context, **options):
"""
Performs an HTTP HEAD Request
:param context: the context url
:param options: the options keyword argument described in doRequest()
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
options['method'] = 'HEAD'
options['context'] = context
return self.doRequest(**options)
def put(self, context, body, **options):
"""
Performs an HTTP PUT Request
:param context: the context url
:param body: the body of the HTTP request
:param options: the options keyword argument described in doRequest()
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
options['method'] = 'PUT'
options['context'] = context
options['body'] = body
return self.doRequest(**options)
def post(self, context, body, **options):
"""
Performs an HTTP POST Request
:param context: the context url
:param body: the body of the HTTP request
:param options: the options keyword argument described in doRequest()
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
options['method'] = 'POST'
options['context'] = context
options['body'] = body
return self.doRequest(**options)
def delete(self, context, **options):
"""
Performs an HTTP DELETE Request
:param context: the context url
:param options: the options keyword argument described in doRequest()
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
options['method'] = 'DELETE'
options['context'] = context
return self.doRequest(**options)
def patch(self, context, body, **options):
"""
Performs an HTTP PATCH Request
:param context: the context url
:param body: the body of the HTTP request
:param options: the options keyword argument described in doRequest()
:return: an <a href="/jython-docs/#!/_PROD_VERSION_/service/HttpResponse.HttpResponse">HttpResponse</a> instance
"""
options['method'] = 'PATCH'
options['context'] = context
options['body'] = body
return self.doRequest(**options)
def buildRequest(self, method, context, body, contentType, headers,
quotePlus):
url = self.quote(self.createPath(self.params.getUrl(), context),
quotePlus)
method = method.upper()
self.logger.debug('buildRequest: method: %s' % method)
self.logger.debug('buildRequest: url: %s' % url)
self.logger.debug('buildRequest: content-type: %s' % contentType)
if method == 'GET':
request = HttpGet(url)
elif method == 'HEAD':
request = HttpHead(url)
elif method == 'POST':
request = HttpPost(url)
request.setEntity(StringEntity(str(body)))
elif method == 'PUT':
request = HttpPut(url)
request.setEntity(StringEntity(str(body)))
elif method == 'DELETE':
request = HttpDelete(url)
elif method == 'PATCH':
request = HttpPatch(url)
request.setEntity(StringEntity(body))
else:
raise Exception('Unsupported method: ' + method)
request.addHeader('Content-Type', contentType)
request.addHeader('Accept', contentType)
self.setCredentials(request)
self.setProxy(request)
self.setHeaders(request, headers)
return request
def createPath(self, url, context):
url = re.sub('/*$', '', url)
if context is None:
return url
elif context.startswith('/'):
return url + context
else:
return url + '/' + context
def quote(self, url, quotePlus):
if quotePlus:
return urllib.quote_plus(url, ':/?&=%')
else:
return urllib.quote(url, ':/?&=%')
def setCredentials(self, request):
if self.username:
username = self.username
password = self.password
elif self.params.getUsername():
username = self.params.getUsername()
password = self.params.getPassword()
else:
return
encoding = Base64.encodeBase64String(
String(username + ':' + password).getBytes('ISO-8859-1'))
request.addHeader('Authorization', 'Basic ' + encoding)
def setProxy(self, request):
if not self.params.getProxyHost():
return
proxy = HttpHost(self.params.getProxyHost(),
int(self.params.getProxyPort()))
config = RequestConfig.custom().setProxy(proxy).build()
request.setConfig(config)
def setHeaders(self, request, headers):
if headers:
for key in headers:
request.setHeader(key, headers[key])
def executeRequest(self, request):
self.logger.debug('executeRequest: request: %s' % repr(request))
client = None
response = None
try:
client = HttpClients.createDefault()
response = client.execute(request)
self.logger.debug('executeRequest: response: %s' % repr(response))
status = response.getStatusLine().getStatusCode()
self.logger.debug('executeRequest: status: %s' % status)
entity = response.getEntity()
data = EntityUtils.toString(entity, "UTF-8") if entity else None
headers = response.getAllHeaders()
EntityUtils.consume(entity)
return HttpResponse(status, data, headers)
except Exception as e:
self.logger.error('executeRequest: failed: %s' % repr(e))
raise e
finally:
if response:
response.close()
if client:
client.close()
import httplib
import base64
import string
from xml.dom.minidom import parse, parseString
from com.xebialabs.xlrelease.domain.configuration import HttpConnection
#url="http://localhost:8080/view/List/job/PetPortal-build-only/ws/dar/target/PetPortal-3.0-CD-SNAPSHOT.dar"
xld_conn = HttpConnection({
'url': 'http://localhost:4516',
'username': '******',
'password': '******'
})
xld_request = HttpRequest(xld_request, 'admin', 'admin')
url = "%s/view/List/job/%s/ws/%s" % (jenkinsServer['url'], jobName,
pathInWorkspace)
print "URL %s " % (url)
importReponse = xld_request.post("/deployit/package/fetch",
url,
contentType='application/xml')
if buildResponse.isSuccessful():
dom = parseString(importResponse.response)
version = dom.getElementsByTagName("udm.DeploymentPackage")[0]
#auth = base64.encodestring('%s:%s' % (username, password)).replace('\n', '')
#headers = {"Content-type": "application/xml", "Accept": "application/xml","Authorization":"Basic %s" % auth}
#conn = httplib.HTTPConnection("localhost:4516")
#conn.request("POST", "/deployit/package/fetch", url, headers)
response = conn.getresponse()
print response
