def Search(self, request, context):
query = request.query
query = urllib.urlencode({'q': query})
response = urllib.urlopen(
'http://ajax.googleapis.com/ajax/services/search/web?v=1.0&' + query)
.read()
_json = json.loads(response)
results = _json['responseData']['results']
for result in results:
yield result
def get_static_google_map_image_url(self):
"""
https://developers.google.com/maps/documentation/staticmaps/
Example URL:
http://maps.googleapis.com/maps/api/staticmap?center=Brooklyn+Bridge,New+York,NY&zoom=13&size=600x300&maptype=roadmap&markers=color:blue%7Clabel:S%7C40.702147,-74.015794&markers=color:green%7Clabel:G%7C40.711614,-74.012318&markers=color:red%7Clabel:C%7C40.718217,-73.998284&sensor=false
"""
width = 301
height = 234
str_value = self.__str__()
base_url = 'http://maps.googleapis.com/maps/api/staticmap?'
query = urllib.urlencode({
'center': str_value,
'markers': 'color:green|%s' % str_value,
'zoom': 13,
'size': '%dx%d' % (
width,
height,
),
'maptype': 'roadmap',
'sensor': 'false',
})
url = base_url + query
return url
def onAuthenticate(self, signature, extra):
"""
Callback fired when a client responds to an authentication challenge.
"""
print("onAuthenticate: {} {}".format(signature, extra))
# if there is a pending auth, check the challenge response. The specifics
# of how to check depend on the authentication method
#
if self._pending_auth:
# WAMP-CRA
#
if isinstance(self._pending_auth, PendingAuthWampCra):
if signature == self._pending_auth.signature:
# WAMP-CRA authentication signature was valid: accept the client
#
return types.Accept(authid=self._pending_auth.authid,
authrole=self._pending_auth.authrole,
authmethod=self._pending_auth.authmethod,
authprovider=self._pending_auth.authprovider)
else:
# WAMP-CRA authentication signature was invalid: deny client
#
return types.Deny(message=u"signature is invalid")
# WAMP-Ticket
#
elif isinstance(self._pending_auth, PendingAuthTicket):
# when doing WAMP-Ticket from static configuration, the ticket we
# expect was store on the pending authentication object and we just compare ..
#
if self._pending_auth.authprovider == 'static':
if signature == self._pending_auth.ticket:
# WAMP-Ticket authentication ticket was valid: accept the client
#
return types.Accept(authid=self._pending_auth.authid,
authrole=self._pending_auth.authrole,
authmethod=self._pending_auth.authmethod,
authprovider=self._pending_auth.authprovider)
else:
# WAMP-Ticket authentication ticket was invalid: deny client
#
return types.Deny(message=u"ticket is invalid")
# WAMP-Ticket dynamic ..
#
else:
# call the configured dynamic authenticator procedure
# via the router's service session
#
service_session = self._router_factory.get(self._pending_auth.realm)._realm.session
d = service_session.call(self._pending_auth.authprovider,
self._pending_auth.realm,
self._pending_auth.authid,
signature)
def on_authenticate_ok(principal):
if isinstance(principal, dict):
# dynamic ticket authenticator returned a dictionary (new)
authid = principal.get("authid", self._pending_auth.authid)
authrole = principal["role"]
else:
# backwards compatibility: dynamic ticket authenticator
# was expected to return a role directly
authid = self._pending_auth.authid
authrole = principal
return types.Accept(authid=authid,
authrole=authrole,
authmethod=self._pending_auth.authmethod,
authprovider=self._pending_auth.authprovider)
def on_authenticate_error(err):
error = None
message = "dynamic WAMP-Ticket credential getter failed: {}".format(err)
if isinstance(err.value, ApplicationError):
error = err.value.error
if err.value.args and len(err.value.args):
message = err.value.args[0]
return types.Deny(error, message)
d.addCallbacks(on_authenticate_ok, on_authenticate_error)
return d
elif isinstance(self._pending_auth, PendingAuthPersona):
dres = Deferred()
# The client did it's Mozilla Persona authentication thing
# and now wants to verify the authentication and login.
assertion = signature
audience = str(self._pending_auth.audience) # eg "http://192.168.1.130:8080/"
provider = str(self._pending_auth.provider) # eg "https://verifier.login.persona.org/verify"
# To verify the authentication, we need to send a HTTP/POST
# to Mozilla Persona. When successful, Persona will send us
# back something like:
# {
# "audience": "http://192.168.1.130:8080/",
# "expires": 1393681951257,
# "issuer": "gmail.login.persona.org",
# "email": "*****@*****.**",
# "status": "okay"
# }
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
body = urllib.urlencode({'audience': audience, 'assertion': assertion})
from twisted.web.client import getPage
d = getPage(url=provider,
method='POST',
postdata=body,
headers=headers)
log.msg("Authentication request sent.")
def done(res):
res = json.loads(res)
try:
if res['status'] == 'okay':
# awesome: Mozilla Persona successfully authenticated the user
self._transport._authid = res['email']
self._transport._authrole = self._pending_auth.role
self._transport._authmethod = 'mozilla_persona'
log.msg("Authenticated user {} with role {}".format(self._transport._authid, self._transport._authrole))
dres.callback(types.Accept(authid=self._transport._authid, authrole=self._transport._authrole, authmethod=self._transport._authmethod))
# remember the user's auth info (this marks the cookie as authenticated)
if self._transport._cbtid and self._transport.factory._cookiestore:
cs = self._transport.factory._cookiestore
cs.setAuth(self._transport._cbtid, self._transport._authid, self._transport._authrole, self._transport._authmethod)
# kick all sessions using same cookie (but not _this_ connection)
if True:
for proto in cs.getProtos(self._transport._cbtid):
if proto and proto != self._transport:
try:
proto.close()
except Exception as e:
pass
else:
log.msg("Authentication failed!")
log.msg(res)
dres.callback(types.Deny(reason="wamp.error.authorization_failed", message=res.get("reason", None)))
except Exception as e:
log.msg("internal error during authentication verification: {}".format(e))
dres.callback(types.Deny(reason="wamp.error.internal_error", message=str(e)))
def error(err):
log.msg("Authentication request failed: {}".format(err.value))
dres.callback(types.Deny(reason="wamp.error.authorization_request_failed", message=str(err.value)))
d.addCallbacks(done, error)
return dres
else:
log.msg("don't know how to authenticate")
return types.Deny()
else:
# deny client
return types.Deny(message=u"no pending authentication")
def onAuthenticate(self, signature, extra):
"""
Callback fired when a client responds to an authentication challenge.
"""
print("onAuthenticate: {} {}".format(signature, extra))
# if there is a pending auth, check the challenge response. The specifics
# of how to check depend on the authentication method
#
if self._pending_auth:
# WAMP-CRA
#
if isinstance(self._pending_auth, PendingAuthWampCra):
if signature == self._pending_auth.signature:
# WAMP-CRA authentication signature was valid: accept the client
#
return types.Accept(
authid=self._pending_auth.authid,
authrole=self._pending_auth.authrole,
authmethod=self._pending_auth.authmethod,
authprovider=self._pending_auth.authprovider)
else:
# WAMP-CRA authentication signature was invalid: deny client
#
return types.Deny(message=u"signature is invalid")
# WAMP-Ticket
#
elif isinstance(self._pending_auth, PendingAuthTicket):
# when doing WAMP-Ticket from static configuration, the ticket we
# expect was store on the pending authentication object and we just compare ..
#
if self._pending_auth.authprovider == 'static':
if signature == self._pending_auth.ticket:
# WAMP-Ticket authentication ticket was valid: accept the client
#
return types.Accept(
authid=self._pending_auth.authid,
authrole=self._pending_auth.authrole,
authmethod=self._pending_auth.authmethod,
authprovider=self._pending_auth.authprovider)
else:
# WAMP-Ticket authentication ticket was invalid: deny client
#
return types.Deny(message=u"ticket is invalid")
# WAMP-Ticket dynamic ..
#
else:
# call the configured dynamic authenticator procedure
# via the router's service session
#
service_session = self._router_factory.get(
self._pending_auth.realm)._realm.session
d = service_session.call(self._pending_auth.authprovider,
self._pending_auth.realm,
self._pending_auth.authid,
signature)
def on_authenticate_ok(principal):
if isinstance(principal, dict):
# dynamic ticket authenticator returned a dictionary (new)
authid = principal.get("authid",
self._pending_auth.authid)
authrole = principal["role"]
else:
# backwards compatibility: dynamic ticket authenticator
# was expected to return a role directly
authid = self._pending_auth.authid
authrole = principal
return types.Accept(
authid=authid,
authrole=authrole,
authmethod=self._pending_auth.authmethod,
authprovider=self._pending_auth.authprovider)
def on_authenticate_error(err):
error = None
message = "dynamic WAMP-Ticket credential getter failed: {}".format(
err)
if isinstance(err.value, ApplicationError):
error = err.value.error
if err.value.args and len(err.value.args):
message = err.value.args[0]
return types.Deny(error, message)
d.addCallbacks(on_authenticate_ok, on_authenticate_error)
return d
elif isinstance(self._pending_auth, PendingAuthPersona):
dres = Deferred()
# The client did it's Mozilla Persona authentication thing
# and now wants to verify the authentication and login.
assertion = signature
audience = str(self._pending_auth.audience
) # eg "http://192.168.1.130:8080/"
provider = str(
self._pending_auth.provider
) # eg "https://verifier.login.persona.org/verify"
# To verify the authentication, we need to send a HTTP/POST
# to Mozilla Persona. When successful, Persona will send us
# back something like:
# {
# "audience": "http://192.168.1.130:8080/",
# "expires": 1393681951257,
# "issuer": "gmail.login.persona.org",
# "email": "*****@*****.**",
# "status": "okay"
# }
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
body = urllib.urlencode({
'audience': audience,
'assertion': assertion
})
from twisted.web.client import getPage
d = getPage(url=provider,
method='POST',
postdata=body,
headers=headers)
self.log.info("Authentication request sent.")
def done(res):
res = json.loads(res)
try:
if res['status'] == 'okay':
# awesome: Mozilla Persona successfully authenticated the user
self._transport._authid = res['email']
self._transport._authrole = self._pending_auth.role
self._transport._authmethod = 'mozilla_persona'
self.log.info(
"Authenticated user {} with role {}".format(
self._transport._authid,
self._transport._authrole))
dres.callback(
types.Accept(
authid=self._transport._authid,
authrole=self._transport._authrole,
authmethod=self._transport._authmethod))
# remember the user's auth info (this marks the cookie as authenticated)
if self._transport._cbtid and self._transport.factory._cookiestore:
cs = self._transport.factory._cookiestore
cs.setAuth(self._transport._cbtid,
self._transport._authid,
self._transport._authrole,
self._transport._authmethod)
# kick all sessions using same cookie (but not _this_ connection)
if True:
for proto in cs.getProtos(
self._transport._cbtid):
if proto and proto != self._transport:
try:
proto.close()
except Exception as e:
pass
else:
self.log.info("Authentication failed!")
self.log.info(res)
dres.callback(
types.Deny(
reason="wamp.error.authorization_failed",
message=res.get("reason", None)))
except Exception as e:
self.log.info(
"internal error during authentication verification: {}"
.format(e))
dres.callback(
types.Deny(reason="wamp.error.internal_error",
message=str(e)))
def error(err):
self.log.info("Authentication request failed: {}".format(
err.value))
dres.callback(
types.Deny(
reason="wamp.error.authorization_request_failed",
message=str(err.value)))
d.addCallbacks(done, error)
return dres
else:
self.log.info("don't know how to authenticate")
return types.Deny()
else:
# deny client
return types.Deny(message=u"no pending authentication")
def onAuthenticate(self, signature, extra):
if isinstance(self._pending_auth, PendingAuthPersona):
dres = Deferred()
## The client did it's Mozilla Persona authentication thing
## and now wants to verify the authentication and login.
assertion = signature
audience = str(
self._pending_auth.audience) # eg "http://192.168.1.130:8080/"
provider = str(self._pending_auth.provider
) # eg "https://verifier.login.persona.org/verify"
## To verify the authentication, we need to send a HTTP/POST
## to Mozilla Persona. When successful, Persona will send us
## back something like:
# {
# "audience": "http://192.168.1.130:8080/",
# "expires": 1393681951257,
# "issuer": "gmail.login.persona.org",
# "email": "*****@*****.**",
# "status": "okay"
# }
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
body = urllib.urlencode({
'audience': audience,
'assertion': assertion
})
from twisted.web.client import getPage
d = getPage(url=provider,
method='POST',
postdata=body,
headers=headers)
log.msg("Authentication request sent.")
def done(res):
res = json.loads(res)
try:
if res['status'] == 'okay':
## awesome: Mozilla Persona successfully authenticated the user
self._transport._authid = res['email']
self._transport._authrole = self._pending_auth.role
self._transport._authmethod = 'mozilla_persona'
log.msg("Authenticated user {} with role {}".format(
self._transport._authid,
self._transport._authrole))
dres.callback(
types.Accept(
authid=self._transport._authid,
authrole=self._transport._authrole,
authmethod=self._transport._authmethod))
## remember the user's auth info (this marks the cookie as authenticated)
if self._transport._cbtid and self._transport.factory._cookiestore:
cs = self._transport.factory._cookiestore
cs.setAuth(self._transport._cbtid,
self._transport._authid,
self._transport._authrole,
self._transport._authmethod)
## kick all sessions using same cookie (but not _this_ connection)
if True:
for proto in cs.getProtos(
self._transport._cbtid):
if proto and proto != self._transport:
try:
proto.close()
except Exception as e:
pass
else:
log.msg("Authentication failed!")
log.msg(res)
dres.callback(
types.Deny(
reason="wamp.error.authorization_failed",
message=res.get("reason", None)))
except Exception as e:
log.msg(
"internal error during authentication verification: {}"
.format(e))
dres.callback(
types.Deny(reason="wamp.error.internal_error",
message=str(e)))
def error(err):
log.msg("Authentication request failed: {}".format(err.value))
dres.callback(
types.Deny(
reason="wamp.error.authorization_request_failed",
message=str(err.value)))
d.addCallbacks(done, error)
return dres
else:
log.msg("don't know how to authenticate")
return types.Deny()
def shuffle_qs(qs):
qs_parts = urllib.parse.parse_qsl(qs)
random.shuffle(qs_parts)
return urllib.urlencode(qs_parts)
def sorted_qs(qs):
# we use parse_qsl to avoid getting multiple values as list and to preserve
# the order of the qs_params
qs_parts = urllib.parse.parse_qsl(qs)
qs_parts_sorted = sorted(qs_parts)
return urllib.urlencode(qs_parts_sorted)
def run():
sess = requests.session()
sess.auth = ('vagrant', 'vagrant')
API_URL = 'http://localhost:8000/api/v1/'
# Make an app record, if vr_node_example isn't already there.
app_name = 'vr_node_example'
app_url = API_URL + 'apps/%s/' % app_name
r = sess.get(app_url)
if r.status_code == 404:
# App not found. Make it!
app_data = json.dumps({
"name":
app_name,
"repo_type":
"hg",
"repo_url":
"https://bitbucket.org/btubbs/vr_node_example"
})
r = sess.post(API_URL + 'apps/', data=app_data)
# Throw exception and bail out if this fails
r.raise_for_status()
# Make a buildpack record, if necessary. Buildpacks
# don't have nice natural
# keys like apps do, so we'll search.
node_buildpack_url = (
'https://github.com/heroku/heroku-buildpack-nodejs.git')
buildpack_search_url = API_URL + 'buildpacks/?' + urllib.urlencode(
{'repo_url': node_buildpack_url})
r = sess.get(buildpack_search_url)
results = r.json()['objects']
if not len(results):
# Not buildpack record found with that URL. Make one.
buildpack_data = json.dumps({
'repo_url': node_buildpack_url,
'repo_type': 'git',
'order': 0,
})
r = sess.post(API_URL + 'buildpacks/', data=buildpack_data)
assert r.status_code == 201
# Make a build record
build_data = json.dumps({
'app': urllib.parse.urlparse(app_url).path,
'tag': 'v4',
})
r = sess.post(API_URL + 'builds/', data=build_data)
assert r.status_code == 201
build_url = r.headers['location']
# Tell VR to build it
r = sess.post(build_url + 'build/')
# Watch the output
stream_url = 'http://localhost:8000/api/streams/events/'
for message in sseclient.SSEClient(stream_url, auth=sess.auth):
print(message.id, message)
def onAuthenticate(self, signature, extra):
"""
Callback fired when a client responds to an authentication challenge.
"""
print("onAuthenticate: {} {}".format(signature, extra))
## if there is a pending auth, and the signature provided by client matches ..
if self._pending_auth:
if isinstance(self._pending_auth, PendingAuthWampCra):
if signature == self._pending_auth.signature:
## accept the client
return types.Accept(authid = self._pending_auth.authid,
authrole = self._pending_auth.authrole,
authmethod = self._pending_auth.authmethod,
authprovider = self._pending_auth.authprovider)
else:
## deny client
return types.Deny(message = u"signature is invalid")
elif isinstance(self._pending_auth, PendingAuthPersona):
dres = Deferred()
## The client did it's Mozilla Persona authentication thing
## and now wants to verify the authentication and login.
assertion = signature
audience = str(self._pending_auth.audience) # eg "http://192.168.1.130:8080/"
provider = str(self._pending_auth.provider) # eg "https://verifier.login.persona.org/verify"
## To verify the authentication, we need to send a HTTP/POST
## to Mozilla Persona. When successful, Persona will send us
## back something like:
# {
# "audience": "http://192.168.1.130:8080/",
# "expires": 1393681951257,
# "issuer": "gmail.login.persona.org",
# "email": "*****@*****.**",
# "status": "okay"
# }
headers = {'Content-Type': 'application/x-www-form-urlencoded'}
body = urllib.urlencode({'audience': audience, 'assertion': assertion})
from twisted.web.client import getPage
d = getPage(url = provider,
method = 'POST',
postdata = body,
headers = headers)
log.msg("Authentication request sent.")
def done(res):
res = json.loads(res)
try:
if res['status'] == 'okay':
## awesome: Mozilla Persona successfully authenticated the user
self._transport._authid = res['email']
self._transport._authrole = self._pending_auth.role
self._transport._authmethod = 'mozilla_persona'
log.msg("Authenticated user {} with role {}".format(self._transport._authid, self._transport._authrole))
dres.callback(types.Accept(authid = self._transport._authid, authrole = self._transport._authrole, authmethod = self._transport._authmethod))
## remember the user's auth info (this marks the cookie as authenticated)
if self._transport._cbtid and self._transport.factory._cookiestore:
cs = self._transport.factory._cookiestore
cs.setAuth(self._transport._cbtid, self._transport._authid, self._transport._authrole, self._transport._authmethod)
## kick all sessions using same cookie (but not _this_ connection)
if True:
for proto in cs.getProtos(self._transport._cbtid):
if proto and proto != self._transport:
try:
proto.close()
except Exception as e:
pass
else:
log.msg("Authentication failed!")
log.msg(res)
dres.callback(types.Deny(reason = "wamp.error.authorization_failed", message = res.get("reason", None)))
except Exception as e:
log.msg("internal error during authentication verification: {}".format(e))
dres.callback(types.Deny(reason = "wamp.error.internal_error", message = str(e)))
def error(err):
log.msg("Authentication request failed: {}".format(err.value))
dres.callback(types.Deny(reason = "wamp.error.authorization_request_failed", message = str(err.value)))
d.addCallbacks(done, error)
return dres
else:
log.msg("don't know how to authenticate")
return types.Deny()
else:
## deny client
return types.Deny(message = u"no pending authentication")
def shuffle_qs(qs):
qs_parts = urllib.parse.parse_qsl(qs)
random.shuffle(qs_parts)
return urllib.urlencode(qs_parts)
def sorted_qs(qs):
# we use parse_qsl to avoid getting multiple values as list and to preserve
# the order of the qs_params
qs_parts = urllib.parse.parse_qsl(qs)
qs_parts_sorted = sorted(qs_parts)
return urllib.urlencode(qs_parts_sorted)
def request(method,
url,
params=None,
data=None,
headers=None,
cookies=None,
files=None,
auth=None,
timeout=60,
allow_redirects=False,
stream=False):
"""Initiate an HTTP(S) request. Returns :class:`Response` object.
:param method: 'GET' or 'POST'
:type method: unicode
:param url: URL to open
:type url: unicode
:param params: mapping of URL parameters
:type params: dict
:param data: mapping of form data ``{'field_name': 'value'}`` or
:class:`str`
:type data: dict or str
:param headers: HTTP headers
:type headers: dict
:param cookies: cookies to send to server
:type cookies: dict
:param files: files to upload (see below).
:type files: dict
:param auth: username, password
:type auth: tuple
:param timeout: connection timeout limit in seconds
:type timeout: int
:param allow_redirects: follow redirections
:type allow_redirects: bool
:param stream: Stream content instead of fetching it all at once.
:type stream: bool
:returns: Response object
:rtype: :class:`Response`
The ``files`` argument is a dictionary::
{'fieldname' : { 'filename': 'blah.txt',
'content': '<binary data>',
'mimetype': 'text/plain'}
}
* ``fieldname`` is the name of the field in the HTML form.
* ``mimetype`` is optional. If not provided, :mod:`mimetypes` will
be used to guess the mimetype, or ``application/octet-stream``
will be used.
"""
# TODO: cookies
socket.setdefaulttimeout(timeout)
# Default handlers
openers = [urllib2.ProxyHandler(urllib2.getproxies())]
if not allow_redirects:
openers.append(NoRedirectHandler())
if auth is not None: # Add authorisation handler
username, password = auth
password_manager = urllib2.HTTPPasswordMgrWithDefaultRealm()
password_manager.add_password(None, url, username, password)
auth_manager = urllib2.HTTPBasicAuthHandler(password_manager)
openers.append(auth_manager)
# Install our custom chain of openers
opener = urllib2.build_opener(*openers)
urllib2.install_opener(opener)
if not headers:
headers = CaseInsensitiveDictionary()
else:
headers = CaseInsensitiveDictionary(headers)
if 'user-agent' not in headers:
headers['user-agent'] = USER_AGENT
# Accept gzip-encoded content
encodings = [
s.strip() for s in headers.get('accept-encoding', '').split(',')
]
if 'gzip' not in encodings:
encodings.append('gzip')
headers['accept-encoding'] = ', '.join(encodings)
if files:
if not data:
data = {}
new_headers, data = encode_multipart_formdata(data, files)
headers.update(new_headers)
elif data and isinstance(data, dict):
data = urllib.urlencode(str_dict(data))
# Make sure everything is encoded text
headers = str_dict(headers)
if isinstance(url, unicode):
url = url.encode('utf-8')
if params: # GET args (POST args are handled in encode_multipart_formdata)
scheme, netloc, path, query, fragment = urlparse.urlsplit(url)
if query: # Combine query string and `params`
url_params = urlparse.parse_qs(query)
# `params` take precedence over URL query string
url_params.update(params)
params = url_params
query = urllib.urlencode(str_dict(params), doseq=True)
url = urlparse.urlunsplit((scheme, netloc, path, query, fragment))
req = Request(url, data, headers, method=method)
return Response(req, stream)
