def _old_request_ended(self, shard_state):
"""Whether previous slice retry has ended according to Logs API.
Args:
shard_state: shard state.
Returns:
True if the request of previous slice retry has ended. False if it has
not or unknown.
"""
assert shard_state.slice_start_time is not None
assert shard_state.slice_request_id is not None
request_ids = [shard_state.slice_request_id]
try:
logs = list(logservice.fetch(request_ids=request_ids))
except logservice.InvalidArgumentError:
global using_modules
if using_modules:
logs = list(logservice.fetch(
request_ids=request_ids,
module_versions=[(modules.get_current_module_name(),
modules.get_current_version_name())]))
else:
logs = list(logservice.fetch(
request_ids=request_ids,
server_versions=[(servers.get_current_server_name(),
servers.get_current_version_name())]))
if not logs or not logs[0].finished:
return False
return True
def calculate_timeout(self):
timeout = 30
if modules.get_current_module_name() == "robot":
logging.info("Detected that we are at 'robot' module <3")
timeout = 3600
logging.info("The timeout of this request is of %d seconds", timeout)
return timeout
def run(self, job_name, input_files):
empty = True
for filename in input_files:
if files.stat(filename).st_size > 0:
empty = False
break
if empty:
self.complete([])
return
shard_number = len(input_files)
output_files = []
for i in range(shard_number):
blob_file_name = (job_name + "-shuffle-output-" + str(i))
file_name = files.blobstore.create(
_blobinfo_uploaded_filename=blob_file_name)
output_files.append(file_name)
self.fill(self.outputs._output_files, output_files)
target = modules.get_current_version_name()
module_name = modules.get_current_module_name()
if module_name != "default":
target = "%s.%s." % (target, module_name)
files.shuffler.shuffle(
"%s-%s" % (job_name, int(time.time())), input_files, output_files,
{
"url": self.get_callback_url(),
"method": "GET",
"queue": self.queue_name,
"version": target,
})
def getProfesores(self, unused_request):
'''
Devuelve una lista con todos los profesores registrados en el sistema, de forma simplificada (solo nombre y DNI)
Llamada desde terminal:
curl -X GET localhost:8001/_ah/api/helloworld/v1/profesores/getProfesores
Llamada desde JavaScript:
response =service.profesores.getProfesores().execute()
'''
#Identificación del módulo en el que estamos.
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
#Leclear decimos a que microservicio queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
url = "http://%s/" % modules.get_hostname(module="microservicio1")
#Añadimos el recurso al que queremos conectarnos.
url+="profesores"
if v:
print str(url)
#Al no especificar nada se llama al método GET de la URL.
result = urlfetch.fetch(url)
if v:
print result.content
listaProfesores = jsonpickle.decode(result.content)
#Creamos un vector
profesoresItems= []
#Que rellenamos con todo los profesores de la listaProfesores
for profesore in listaProfesores:
profesoresItems.append(Profesor( nombre=str(alumno.get('nombre')), dni=str(alumno.get('dni')) ))
#Los adaptamos al tipo de mensaje y enviamos
#return Greeting(message=str(result.content))
return ListaAlumnos(alumnos=alumnosItems)
def get(cls):
key = ndb.Key(cls, modules.get_current_module_name())
inst = key.get()
if not inst:
inst = cls(key=key)
inst.put()
return inst
def post(self):
x = self.request.get('x')
if (x == ''):
self.redirect('/%s' % modules.get_current_module_name())
form_fields = {
'x' : x
}
url = "http://%s/sqrt/" % modules.get_hostname(module="webmath")
form_data = urllib.urlencode(form_fields)
result = urlfetch.fetch(url=url,
payload = form_data,
method = urlfetch.POST,
headers={'Content-Type': 'application/x-www-form-urlencoded'})
if (result.status_code == 200) :
squareroot = result.content
else:
squareroot = result.status_code
template_values = {
'x': x,
'result': squareroot
}
self.render('result', template_values)
def addTask(queues, func, *args, **kwargs):
""" Enqueue a task to execute the specified function call later from the task queue.
Handle exceptions and dispatching to the right queue.
@param queues: List of queues names. We will randomly select one to push the task into.
Can be 'default' to use default queues.
@param func: The function to execute later
@param _countdown: seconds to wait before calling the function
@param _eta: timestamp defining when to call the function
@param _name: Name to give the Task; if not specified, a name will be
auto-generated when added to a queue and assigned to this object.
Must match the _TASK_NAME_PATTERN regular expression: ^[a-zA-Z0-9_-]{1,500}$
@param _target: specific version and/or module the task should execute on
@param _raiseIfExists: if set to True, we raise the eventual TaskAlreadyExistsError
@param _transactional: to make sure task in enqueued in the task queue
@param _retry_options: task queue retry options
@param _parent: ndb Key instance, if provided, function payload will be stored in data store entity under this
parent if the size of payload exceeds 100KB. Max size of payload could be 1MB otherwise data store will throw error
@return: A Future that will yield True if the task could be enqueued.
@rtype: ndb.Future
"""
if not isinstance(queues, list):
queues = DEFAULT_QUEUES
_raiseIfExists = kwargs.pop('_raiseIfExists', False)
taskName = kwargs.pop('_name', None)
countdown = kwargs.pop('_countdown', None)
eta = kwargs.pop('_eta', None)
target = kwargs.pop('_target', None)
transactional = kwargs.pop('_transactional', False)
retry_options = kwargs.pop('_retry_options', None)
parent = kwargs.pop('_parent', None)
if not target and BACKGROUND_MODULE:
# Tasks from the default module are executed into the background module.
# Tasks from other modules (stage, background) stays inside their module.
if modules.get_current_module_name() == 'default':
# Target mirror of current version to avoid compatibility issues
# If that version does not exist, it will fall back to the default background version.
target = modules.get_current_version_name() + '.' + BACKGROUND_MODULE
success = False
try:
yield _defer(queues, func, args, kwargs, countdown, eta, taskName, target, transactional, retry_options, parent)
success = True
except (taskqueue.TaskAlreadyExistsError, taskqueue.TombstonedTaskError):
# TaskAlreadyExistsError: a task with same name is in the queue
# TombstonedTaskError: a task with same name has been in the queue recently
if taskName:
# If we specified a name it's to avoid duplicated so this error is expected
logging.info("TaskAlreadyExistsError: task with name %s already enqueued.", taskName)
if _raiseIfExists:
raise
else:
logging.exception("Could not enqueue the task")
except:
logging.exception("Could not enqueue the task")
raise ndb.Return(success)
def inner(self, *argv, **kwargv):
if modules.get_current_module_name() != tap.config.BACKEND_NAME:
cache = yield self.has_cache_async(expire, temporary=temporary)
if cache:
return
ndb.toplevel(func)(self, *argv, **kwargv)
if self.response.status_int == 200:
if empty or len(self.response.body) > 0:
self.put_cache(period, temporary=temporary)
def postProfesor():
'''
Método que inserta un nuevo profesor en el sistema.
curl -d "nombre=Juan&apellidos=Bartlo&dni=46666&direccion=Calle arabl&localidad=Jerez de la fronta&provincia=Granada&fecha_nacimiento=1988-2-6&telefono=137631" -i -X POST localhost:8002/profesores
'''
if v:
print nombreMicroservicio
print " Calling postProfesor()"
print " "+str(request.form)
salida = GestorProfesores.nuevoProfesor(request.form['nombre'],
request.form['apellidos'],
request.form['dni'],
request.form['direccion'],
request.form['localidad'],
request.form['provincia'],
request.form['fecha_nacimiento'],
request.form['telefono'],
)
#Una vez creado el profesor añadimos sus crendenciales de acceso al sistema básicas
if salida['status']=='OK':
print ' Profesor creado con éxito. Creando sus credenciales de acceso al sistema.'
#Creamos las credenciales del usuario en la tabla credenciales usando el id del usuario que devuelve nuevoProfesor
#Por defecto el alias y el password de un profesor en el sistemas serán su dni
#salida Creacion Credenciales
salidaCC=GestorCredenciales.postCredenciales(salida['idProfesor'], request.form['nombre'], request.form['dni'], request.form['dni'], 'admin')
if salidaCC != 'OK':
salida['status']='SBD ERROR'
#Una vez creadas las credenciales llamamos al servicio SCE para que actualice su sistema (### DISPARADOR ###)
#Conformamos la dirección:
module = modules.get_current_module_name()
url = "http://%s/" % modules.get_hostname(module="sce")
#Añadimos el servicio al que queremos conectarnos.
url+="profesores"
#Creamos un diccionario con los datos.
datos = {
"idProfesor": salida['idProfesor'],
"nombreProfesor": request.form['nombre']+' '+request.form['apellidos'],
}
form_data = urllib.urlencode(datos)
result=urlfetch.fetch(url=url, payload=form_data, method=urlfetch.POST)
json = jsonpickle.decode(result.content)
if json['status']!='OK':
salida['status']='SCE ERROR'
if v:
print ' Return: '+str(salida)
return jsonpickle.encode(salida)
def render_response(self, template_name, **context): self.response.headers['Content-Type'] = 'text/html' template = JINJA_ENVIRONMENT.get_template(template_name) context['user'] = users.get_current_user() context['application_id'] = app_identity.get_application_id() context['module_id'] = modules.get_current_module_name() context['version_id'] = modules.get_current_version_name() context['IS_DEVSERVER'] = appengine_config.IS_DEVSERVER self.response.write(template.render(**context))
def get(self):
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
version = modules.get_current_version_name()
self.complete('respond', {
'module': module,
'instance': instance,
'version': version
})
def get(self):
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
version = modules.get_current_version_name()
self.complete('respond', {
'module': module,
'instance': instance,
'version': version
})
def get(self):
query = models.EmailHash.query()
obj = [x for x in query.fetch() if x.uid is not None]
self.response.headers['Content-Type'] = 'application/json'
self.response.write(json.dumps(obj, cls=models.ModelEncoder))
module = modules.get_current_module_name()
instance_id = modules.get_current_instance_id()
def get(self):
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
# self.response.write('Module {0}, instance {1}'.format(module, instance))
current_games = games.Game.find_games()
template_values = {
'current_module_name': module,
'current_instance_id': instance,
'current_games': current_games
}
path = os.path.join(os.path.dirname(__file__), 'index.html')
self.response.out.write(template.render(path, template_values))
def get(self):
self.response.headers['Content-Type'] = 'application/json'
current_module = get_current_module_name()
self.response.out.write(
json.dumps({
'modules': get_modules(),
'current_module_versions': get_versions(current_module),
'default_version': get_default_version(current_module),
'current_module': current_module,
'current_version': get_current_version_name(),
'current_instance_id': get_current_instance_id()
}))
def get(self):
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
# self.response.write('Module {0}, instance {1}'.format(module, instance))
current_games = games.Game.find_games()
template_values = {
'current_module_name': module,
'current_instance_id': instance,
'current_games': current_games
}
path = os.path.join(os.path.dirname(__file__), 'index.html')
self.response.out.write(template.render(path, template_values))
def render(self, page, values):
"""
Add module info to template values
and render template
"""
values['module'] = modules.get_current_module_name()
values['instance'] = modules.get_current_instance_id()
values['version'] = modules.get_current_version_name()
values['handler'] = self.handlerName
template = self.jinjaEnvironment.get_template(self.handlerName + '/' + page + '.html')
self.response.out.write(template.render(values))
def getAlumno(self,request):
print "GET CON PARÁMETROS EN ENDPOINT"
#Cuando se llama a este recurso lo que se quiere es recibir toda la información
#de una entidad Alumno, para ello primero vamos a recuperar la información del microsrevicio apropiado:
#Conexión a un microservicio específico:
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
#Le decimos al microservicio que queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
url = "http://%s/" % modules.get_hostname(module="microservicio1")
'''
Según la doc. de urlfetch (ver arriba) no podemos pasar parámetros con el payload, así que como conocemos
la api del microservicios al que vamos a llamr realizamos la petición bajo su especificacion, según la cual
solo tenemos que llamar a /alumnos/<id_alumno> entonces concatenamos a la url esa id qu recibimos en la llamada
a este procedimiento.
'''
#Recursos más entidad
url+='alumnos/'+request.dni
if v:
print "calling: "+ url
#Petición al microservicio
result = urlfetch.fetch(url=url, method=urlfetch.GET)
print "RESULTADO:"+str(result.status_code)
#print result.content
if v:
print result.status_code
if str(result.status_code) == '400':
raise endpoints.BadRequestException('Peticion erronea')
if str(result.status_code) == '404':
raise endpoints.NotFoundException('Alumno con DNI %s no encontrado.' % (request.dni))
alumno = jsonpickle.decode(result.content)
return AlumnoCompleto(nombre=alumno.get('nombre'),
dni=alumno.get('dni'),
direccion=alumno.get('direccion'),
localidad=alumno.get('localidad'),
provincia=alumno.get('provincia'),
fecha_nac=str(alumno.get('fecha_nac')),
telefono=alumno.get('telefono')
)
def getAsignaturasAlumno(self, request):
if v:
print ("Ejecución de getAsignaturasAlumno en apigateway")
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
url = "http://%s/" % modules.get_hostname(module="microservicio1")
url+='alumnos/'+request.dni+"/asignaturas"
result = urlfetch.fetch(url)
if v:
print result.content
listaAsignaturas = jsonpickle.decode(result.content)
print listaAsignaturas
asignaturasItems= []
for asignatura in listaAsignaturas:
asignaturasItems.append( Asignatura( id=str(asignatura.get('id')), nombre=str(asignatura.get('nombre')) ) )
return ListaAsignaturas(asignaturas=asignaturasItems)
def get(self):
"""
get
"""
MyUtils3.logging_info(modules.get_current_module_name())
MyUtils3.logging_info(self.request.uri)
MyUtils3.logging_info(str(self.request))
for name in os.environ.keys():
MyUtils3.logging_info('{0} : {1}'.format(name, os.environ[name]))
self.response.headers['Content-Type'] = 'text/plain'
self.response.out.write('Hello World')
return
def get(self):
"""
get
"""
MyUtils3.logging_info(modules.get_current_module_name())
MyUtils3.logging_info(self.request.uri)
MyUtils3.logging_info(str(self.request))
for name in os.environ.keys():
MyUtils3.logging_info('{0} : {1}'.format(name, os.environ[name]))
self.response.headers['Content-Type'] = 'text/plain'
self.response.out.write('Hello World')
return
def getCursosAlumno(self, request):
if v:
print ("Ejecución de getCursosAlumno en apigateway")
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
url = "http://%s/" % modules.get_hostname(module="microservicio1")
url+='alumnos/'+request.dni+"/cursos"
result = urlfetch.fetch(url)
if v:
print result.content
listaCursos = jsonpickle.decode(result.content)
print listaCursos
cursosItems= []
for curso in listaCursos:
cursosItems.append(Curso(id=str(curso.get('id')),curso=str(curso.get('nombre')),grupo=str(curso.get('grupo')),nivel=str(curso.get('nivel'))))
return ListaCursos(cursos=cursosItems)
def getAlumno(self, request):
print "GET CON PARÁMETROS EN ENDPOINT"
#Cuando se llama a este recurso lo que se quiere es recibir toda la información
#de una entidad Alumno, para ello primero vamos a recuperar la información del microsrevicio apropiado:
#Conexión a un microservicio específico:
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
#Le decimos al microservicio que queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
url = "http://%s/" % modules.get_hostname(module="microservicio1")
'''
Según la doc. de urlfetch (ver arriba) no podemos pasar parámetros con el payload, así que como conocemos
la api del microservicios al que vamos a llamr realizamos la petición bajo su especificacion, según la cual
solo tenemos que llamar a /alumnos/<id_alumno> entonces concatenamos a la url esa id qu recibimos en la llamada
a este procedimiento.
'''
#Recursos más entidad
url += 'alumnos/' + request.dni
if v:
print "calling: " + url
#Petición al microservicio
result = urlfetch.fetch(url=url, method=urlfetch.GET)
print "RESULTADO:" + str(result.status_code)
#print result.content
if v:
print result.status_code
if str(result.status_code) == '400':
raise endpoints.BadRequestException('Peticion erronea')
if str(result.status_code) == '404':
raise endpoints.NotFoundException(
'Alumno con DNI %s no encontrado.' % (request.dni))
alumno = jsonpickle.decode(result.content)
return AlumnoCompleto(nombre=alumno.get('nombre'),
dni=alumno.get('dni'),
direccion=alumno.get('direccion'),
localidad=alumno.get('localidad'),
provincia=alumno.get('provincia'),
fecha_nac=str(alumno.get('fecha_nac')),
telefono=alumno.get('telefono'))
def getAlumnos(self, unused_request):
#Transformación de la llamada al endpoints a la llamada a la api rest del servicio.
print("Llamando a una función específica")
#Conexión a un microservicio específico:
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
#Le decimos a que microservicio queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
url = "http://%s/" % modules.get_hostname(module="microservicio1")
#Añadimos el recurso al que queremos conectarnos.
url += "alumnos"
print str(url)
#result = urllib2.urlopen(url)
#print result
#Llamamos al microservicio y recibimos los resultados con URLFetch
#Al no especificar nada se llama al método GET de la URL.
result = urlfetch.fetch(url)
#Vamos a intentar consumir los datos en JSON y convertirlos a un mensje enviable :)
print "IMPRESION DE LOS DATOS RECIBIDOS"
print result.content
listaAlumnos = jsonpickle.decode(result.content)
for alumno in listaAlumnos:
print "nombre: " + str(alumno.get('nombre'))
print "dni: " + str(alumno.get('dni'))
'''
miListaAlumnos=ListaAlumnos()
miListaAlumnos.alumnos = listaAlumnos
'''
#Creamos un vector
alumnosItems = []
#Que rellenamos con todo los alumnos de la listaAlumnos
for alumno in listaAlumnos:
alumnosItems.append(
Alumno(nombre=str(alumno.get('nombre')),
dni=str(alumno.get('dni'))))
#Los adaptamos al tipo de mensaje y enviamos
#return Greeting(message=str(result.content))
return ListaAlumnos(alumnos=alumnosItems)
def getAlumnos(self, unused_request):
#Transformación de la llamada al endpoints a la llamada a la api rest del servicio.
print ("Llamando a una función específica")
#Conexión a un microservicio específico:
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
#Le decimos a que microservicio queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
url = "http://%s/" % modules.get_hostname(module="microservicio1")
#Añadimos el recurso al que queremos conectarnos.
url+="alumnos"
print str(url)
#result = urllib2.urlopen(url)
#print result
#Llamamos al microservicio y recibimos los resultados con URLFetch
#Al no especificar nada se llama al método GET de la URL.
result = urlfetch.fetch(url)
#Vamos a intentar consumir los datos en JSON y convertirlos a un mensje enviable :)
print "IMPRESION DE LOS DATOS RECIBIDOS"
print result.content
listaAlumnos = jsonpickle.decode(result.content)
for alumno in listaAlumnos:
print "nombre: "+str(alumno.get('nombre'))
print "dni: "+str(alumno.get('dni'))
'''
miListaAlumnos=ListaAlumnos()
miListaAlumnos.alumnos = listaAlumnos
'''
#Creamos un vector
alumnosItems= []
#Que rellenamos con todo los alumnos de la listaAlumnos
for alumno in listaAlumnos:
alumnosItems.append(Alumno( nombre=str(alumno.get('nombre')), dni=str(alumno.get('dni')) ))
#Los adaptamos al tipo de mensaje y enviamos
#return Greeting(message=str(result.content))
return ListaAlumnos(alumnos=alumnosItems)
def post(self, path):
"""Find and Start the pipeline running."""
(name, api_key) = path.split("/", 1)
p = pipeline.Pipeline.query().filter(pipeline.Pipeline.name == name, pipeline.Pipeline.api_key == api_key).get()
if not p:
self.NotFound("Unable to find pipeline [%s] with api_key [%r]", name, api_key)
return
if modules.get_current_module_name() != "backend":
if users.is_current_user_admin():
self.redirect(self.GetModuleUrl("backend"))
else:
parsed = urlparse.urlparse(self.request.url)
taskqueue.add(queue_name="backend", url=parsed.path, params=urlparse.parse_qs(parsed.query))
return
self.RunPipeline(p)
def getAsignaturasAlumno(self, request):
if v:
print("Ejecución de getAsignaturasAlumno en apigateway")
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
url = "http://%s/" % modules.get_hostname(module="microservicio1")
url += 'alumnos/' + request.dni + "/asignaturas"
result = urlfetch.fetch(url)
if v:
print result.content
listaAsignaturas = jsonpickle.decode(result.content)
print listaAsignaturas
asignaturasItems = []
for asignatura in listaAsignaturas:
asignaturasItems.append(
Asignatura(id=str(asignatura.get('id')),
nombre=str(asignatura.get('nombre'))))
return ListaAsignaturas(asignaturas=asignaturasItems)
def run(self, job_name, input_files):
# Return immediately if we have no content to shuffle.
# Big shuffler can not handle no input.
empty = True
for filename in input_files:
if files.stat(filename).st_size > 0:
empty = False
break
if empty:
self.complete([])
return
shard_number = len(input_files)
output_files = []
for i in range(shard_number):
blob_file_name = (job_name + "-shuffle-output-" + str(i))
file_name = files.blobstore.create(
_blobinfo_uploaded_filename=blob_file_name)
output_files.append(file_name)
self.fill(self.outputs._output_files, output_files)
# Support shuffler callbacks going to specific modules and
# specific non-default versions of those modules.
target = modules.get_current_version_name()
module_name = modules.get_current_module_name()
if module_name != "default":
# NOTE(user): The final dot is necessary here because old versions
# of the shuffler library would put "myversion.12345678" in this field,
# expecting the admin-shuffler app to remove the timestamp suffix.
target = "%s.%s." % (target, module_name)
files.shuffler.shuffle(
"%s-%s" % (job_name, int(time.time())),
input_files,
output_files,
{
"url": self.get_callback_url(),
# NOTE(user): This is always GET because of
# how the admin_shuffler app adds the callback
# task with additional URL params.
"method": "GET",
"queue": self.queue_name,
"version": target,
})
def run(self, job_name, input_files):
# Return immediately if we have no content to shuffle.
# Big shuffler can not handle no input.
empty = True
for filename in input_files:
if files.stat(filename).st_size > 0:
empty = False
break
if empty:
self.complete([])
return
shard_number = len(input_files)
output_files = []
for i in range(shard_number):
blob_file_name = (job_name + "-shuffle-output-" + str(i))
file_name = files.blobstore.create(
_blobinfo_uploaded_filename=blob_file_name)
output_files.append(file_name)
self.fill(self.outputs._output_files, output_files)
# Support shuffler callbacks going to specific modules and
# specific non-default versions of those modules.
target = modules.get_current_version_name()
module_name = modules.get_current_module_name()
if module_name != "default":
# NOTE(user): The final dot is necessary here because old versions
# of the shuffler library would put "myversion.12345678" in this field,
# expecting the admin-shuffler app to remove the timestamp suffix.
target = "%s.%s." % (target, module_name)
files.shuffler.shuffle("%s-%s" % (job_name, int(time.time())),
input_files,
output_files,
{
"url": self.get_callback_url(),
# NOTE(user): This is always GET because of
# how the admin_shuffler app adds the callback
# task with additional URL params.
"method": "GET",
"queue": self.queue_name,
"version": target,
})
def run(self, job_name, input_files):
empty = True
for filename in input_files:
if files.stat(filename).st_size > 0:
empty = False
break
if empty:
self.complete([])
return
shard_number = len(input_files)
output_files = []
for i in range(shard_number):
blob_file_name = (job_name + "-shuffle-output-" + str(i))
file_name = files.blobstore.create(
_blobinfo_uploaded_filename=blob_file_name)
output_files.append(file_name)
self.fill(self.outputs._output_files, output_files)
target = modules.get_current_version_name()
module_name = modules.get_current_module_name()
if module_name != "default":
target = "%s.%s." % (target, module_name)
files.shuffler.shuffle("%s-%s" % (job_name, int(time.time())),
input_files,
output_files,
{
"url": self.get_callback_url(),
"method": "GET",
"queue": self.queue_name,
"version": target,
})
def getProfesoreAlumno(self, request):
#Transformación de la llamada al endpoints a la llamada a la api rest del servicio.
if v:
print ("Ejecución de getProfesoresAlumno en apigateway")
#Conexión a un microservicio específico:
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
#Le decimos a que microservicio queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
url = "http://%s/" % modules.get_hostname(module="microservicio1")
#Añadimos a la url la coleccion (alumnos), el recurso (alumno dado por su dni) y el recurso anidado de este (profesores)
url+='alumnos/'+request.dni+"/profesores"
#Realizamos la petición
result = urlfetch.fetch(url)
#Vamos a intentar consumir los datos en JSON y convertirlos a un mensje enviable :)
print "IMPRESION DE LOS DATOS RECIBIDOS"
print result.content
listaProfesores = jsonpickle.decode(result.content)
#Creamos un vector
profesoresItems= []
#Que rellenamos con todo los alumnos de la listaAlumnos
for profesor in listaProfesores:
profesoresItems.append(ProfesorCompleto( nombre=str(profesor.get('nombre')),
dni=str(profesor.get('dni')),
direccion=str(profesor.get('direccion')),
localidad=str(profesor.get('localidad')),
provincia=str(profesor.get('provincia')),
fecha_nac=str(profesor.get('fecha_nac')),
telefonoA=str(profesor.get('telefonoA')),
telefonoB=str(profesor.get('telefonoB'))
)
)
#Los adaptamos al tipo de mensaje y enviamos
#return Greeting(message=str(result.content))
return ListaProfesores(profesores=profesoresItems)
def postAsignatura():
'''
Inserta una nueva asignatura en el sistema.
curl -d "nombre=ComputacionZZ" -i -X POST localhost:8002/asignaturas
'''
#Info de seguimiento
if v:
print nombreMicroservicio
print ' Recurso: /asignaturas, metodo: POST \n'
print ' Petición '
print request.form
salida = GestorAsignaturas.nuevaAsignatura(request.form['nombre'].encode('latin-1'))
print "Salida del Gestor"
print salida
if salida['status'] == 'OK':
#Una vez insertada la asignatura en el SBD llamamos al servicio SCE para que actualice su sistema (### DISPARADOR ###)
#Conformamos la dirección:
module = modules.get_current_module_name()
url = "http://%s/" % modules.get_hostname(module="sce")
#Añadimos el servicio al que queremos conectarnos.
url+="asignaturas"
#Creamos un diccionario con los datos.
datos = {
"idAsignatura": salida['idAsignatura'],
"nombreAsignatura": request.form['nombre'],
}
form_data = urllib.urlencode(datos)
result=urlfetch.fetch(url=url, payload=form_data, method=urlfetch.POST)
json = jsonpickle.decode(result.content)
if json['status']!='OK':
salida['status']='SCE ERROR'
if v:
print ' Return: '+str(salida)
return jsonpickle.encode(salida)
def getCursosAlumno(self, request):
if v:
print("Ejecución de getCursosAlumno en apigateway")
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
url = "http://%s/" % modules.get_hostname(module="microservicio1")
url += 'alumnos/' + request.dni + "/cursos"
result = urlfetch.fetch(url)
if v:
print result.content
listaCursos = jsonpickle.decode(result.content)
print listaCursos
cursosItems = []
for curso in listaCursos:
cursosItems.append(
Curso(id=str(curso.get('id')),
curso=str(curso.get('nombre')),
grupo=str(curso.get('grupo')),
nivel=str(curso.get('nivel'))))
return ListaCursos(cursos=cursosItems)
def getProfesoreAlumno(self, request):
#Transformación de la llamada al endpoints a la llamada a la api rest del servicio.
if v:
print("Ejecución de getProfesoresAlumno en apigateway")
#Conexión a un microservicio específico:
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
#Le decimos a que microservicio queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
url = "http://%s/" % modules.get_hostname(module="microservicio1")
#Añadimos a la url la coleccion (alumnos), el recurso (alumno dado por su dni) y el recurso anidado de este (profesores)
url += 'alumnos/' + request.dni + "/profesores"
#Realizamos la petición
result = urlfetch.fetch(url)
#Vamos a intentar consumir los datos en JSON y convertirlos a un mensje enviable :)
print "IMPRESION DE LOS DATOS RECIBIDOS"
print result.content
listaProfesores = jsonpickle.decode(result.content)
#Creamos un vector
profesoresItems = []
#Que rellenamos con todo los alumnos de la listaAlumnos
for profesor in listaProfesores:
profesoresItems.append(
ProfesorCompleto(nombre=str(profesor.get('nombre')),
dni=str(profesor.get('dni')),
direccion=str(profesor.get('direccion')),
localidad=str(profesor.get('localidad')),
provincia=str(profesor.get('provincia')),
fecha_nac=str(profesor.get('fecha_nac')),
telefonoA=str(profesor.get('telefonoA')),
telefonoB=str(profesor.get('telefonoB'))))
#Los adaptamos al tipo de mensaje y enviamos
#return Greeting(message=str(result.content))
return ListaProfesores(profesores=profesoresItems)
def postClase():
'''
Inserta una nueva clase en el sistema.
curl -d "curso=3&grupo=C&nivel=ESO" -i -X POST localhost:8002/clases
'''
salida = GestorClases.nuevaClase(request.form['curso'], request.form['grupo'], request.form['nivel'])
if salida['status'] == 'OK':
#Una vez insertada la asignatura en el SBD llamamos al servicio SCE para que actualice su sistema (### DISPARADOR ###)
#Conformamos la dirección:
module = modules.get_current_module_name()
url = "http://%s/" % modules.get_hostname(module="sce")
#Añadimos el servicio al que queremos conectarnos.
url+="clases"
#Componemos el nombre como un solo string
nombreClase = request.form['curso']+request.form['grupo']+request.form['nivel']
print nombreClase
#Creamos un diccionario con los datos.
datos = {
"idClase": salida['idClase'],
"nombreClase": nombreClase,
}
form_data = urllib.urlencode(datos)
result=urlfetch.fetch(url=url, payload=form_data, method=urlfetch.POST)
print result.content
json = jsonpickle.decode(result.content)
print 'AQUIIIIIIIIIIIIIIIIIIIIII'
print json['status']
if json['status']!='OK':
salida['status']='SCE ERROR'
if v:
print ' Return: '+str(salida)
return jsonpickle.encode(salida)
def post(self, path):
"""Find and Start the pipeline running."""
(name, api_key) = path.split('/', 1)
p = pipeline.Pipeline.query().filter(
pipeline.Pipeline.name == name,
pipeline.Pipeline.api_key == api_key).get()
if not p:
self.NotFound('Unable to find pipeline [%s] with api_key [%r]',
name, api_key)
return
if modules.get_current_module_name() != 'backend':
if users.is_current_user_admin():
self.redirect(self.GetModuleUrl('backend'))
else:
# Get the url without the hostname (Taskqueue likes it like that).
url = urlparse.urljoin('http://example.com/', self.request.url)
url = '/' + url.split('/', 3)[-1]
taskqueue.add(queue_name='backend', url=url, params={})
return
self.RunPipeline(p)
def getProfesores(self, unused_request):
'''
Devuelve una lista con todos los profesores registrados en el sistema, de forma simplificada (solo nombre y DNI)
Llamada desde terminal:
curl -X GET localhost:8001/_ah/api/helloworld/v1/profesores/getProfesores
Llamada desde JavaScript:
response =service.profesores.getProfesores().execute()
'''
#Identificación del módulo en el que estamos.
module = modules.get_current_module_name()
instance = modules.get_current_instance_id()
#Leclear decimos a que microservicio queremos conectarnos (solo usando el nombre del mismo), GAE descubre su URL solo.
url = "http://%s/" % modules.get_hostname(module="microservicio1")
#Añadimos el recurso al que queremos conectarnos.
url += "profesores"
if v:
print str(url)
#Al no especificar nada se llama al método GET de la URL.
result = urlfetch.fetch(url)
if v:
print result.content
listaProfesores = jsonpickle.decode(result.content)
#Creamos un vector
profesoresItems = []
#Que rellenamos con todo los profesores de la listaProfesores
for profesore in listaProfesores:
profesoresItems.append(
Profesor(nombre=str(alumno.get('nombre')),
dni=str(alumno.get('dni'))))
#Los adaptamos al tipo de mensaje y enviamos
#return Greeting(message=str(result.content))
return ListaAlumnos(alumnos=alumnosItems)
import ast
import json
import logging
from urllib import urlencode
from util import chunks
from google.appengine.api import modules, urlfetch
from google.appengine.runtime import DeadlineExceededError
import webapp2
MODULE = modules.get_current_module_name()
URLFETCH_DEADLINE = 60
POST_CHUNK_SIZE = 100
class GeospatialIssue(webapp2.RequestHandler):
def options(self):
self.response.headers["Access-Control-Allow-Origin"] = "*"
self.response.headers["Access-Control-Allow-Headers"] = "content-type"
self.response.headers['Content-Type'] = 'application/json'
self.response.write("{}")
return
def get(self):
params = {
'decimalLatitude': self.request.get('decimalLatitude'),
'decimalLongitude': self.request.get('decimalLongitude'),
'countryCode': self.request.get('countryCode'),
'scientificName': self.request.get('scientificName')
}
def get_current_module_name_safe():
"""Returns the current module of the app, or None if there is no current module found.."""
try:
return modules.get_current_module_name()
except KeyError:
return None
def current_module_name(self):
return modules.get_current_module_name()
def process(self): logging.info(modules.get_current_module_name() + ' started') logservice.flush() self.response.set_status(200) return
def initialize(app=None, is_enabled_fn=None, cron_module='default',
is_local_unittest=None):
"""Instruments webapp2 `app` with gae_ts_mon metrics.
Instruments all the endpoints in `app` with basic metrics.
Args:
app (webapp2 app): the app to instrument.
is_enabled_fn (function or None): a function returning bool if ts_mon should
send the actual metrics. None (default) is equivalent to lambda: True.
This allows apps to turn monitoring on or off dynamically, per app.
cron_module (str): the name of the module handling the
/internal/cron/ts_mon/send endpoint. This allows moving the cron job
to any module the user wants.
is_local_unittest (bool or None): whether we are running in a unittest.
"""
if is_local_unittest is None: # pragma: no cover
# Since gae_ts_mon.initialize is called at module-scope by appengine apps,
# AppengineTestCase.setUp() won't have run yet and none of the appengine
# stubs will be initialized, so accessing Datastore or even getting the
# application ID will fail.
is_local_unittest = ('expect_tests' in sys.argv[0])
if is_enabled_fn is not None:
interface.state.flush_enabled_fn = is_enabled_fn
if app is not None:
instrument_wsgi_application(app)
if is_local_unittest or modules.get_current_module_name() == cron_module:
instrument_wsgi_application(handlers.app)
# Use the application ID as the service name and the module name as the job
# name.
if is_local_unittest: # pragma: no cover
service_name = 'unittest'
job_name = 'unittest'
hostname = 'unittest'
else:
service_name = app_identity.get_application_id()
job_name = modules.get_current_module_name()
hostname = modules.get_current_version_name()
runtime.set_shutdown_hook(_shutdown_hook)
interface.state.target = targets.TaskTarget(
service_name, job_name, shared.REGION, hostname, task_num=-1)
interface.state.flush_mode = 'manual'
interface.state.last_flushed = datetime.datetime.utcnow()
# Don't send metrics when running on the dev appserver.
if (is_local_unittest or
os.environ.get('SERVER_SOFTWARE', '').startswith('Development')):
logging.info('Using debug monitor')
interface.state.global_monitor = monitors.DebugMonitor()
else:
logging.info('Using pubsub monitor %s/%s', shared.PUBSUB_PROJECT,
shared.PUBSUB_TOPIC)
interface.state.global_monitor = monitors.PubSubMonitor(
monitors.APPENGINE_CREDENTIALS, shared.PUBSUB_PROJECT,
shared.PUBSUB_TOPIC)
shared.register_global_metrics([shared.appengine_default_version])
shared.register_global_metrics_callback(
shared.INTERNAL_CALLBACK_NAME, _internal_callback)
logging.info('Initialized ts_mon with service_name=%s, job_name=%s, '
'hostname=%s', service_name, job_name, hostname)
def get(self):
# [START module_info]
module = modules.get_current_module_name()
instance_id = modules.get_current_instance_id()
self.response.write(
'module_id={}&instance_id={}'.format(module, instance_id))
