pax_global_header00006660000000000000000000000064124547733050014524gustar00rootroot0000000000000052 comment=b8557bea50e1e206ce8d74efe8bbd761924fd04c rest-python-2.0.0/000077500000000000000000000000001245477330500140175ustar00rootroot00000000000000rest-python-2.0.0/.gitignore000066400000000000000000000000311245477330500160010ustar00rootroot00000000000000apps/* .virtualenv/ *pyc rest-python-2.0.0/COPYRIGHT000066400000000000000000000040441245477330500153140ustar00rootroot00000000000000Copyright © 2012, 2013, 2014 United States Government, as represented by the Secretary of Defense. All rights reserved. Any reproduction of this computer software, or portions thereof, marked with this legend must also reproduce these markings. Copyright © 2009, 2010 Northrop Grumman Corporation. The U.S. Government has Unlimited Rights in this computer software pursuant to the appropriate DFARS clause. Any reproduction of this computer software, or portions thereof, marked with this legend must also reproduce these markings. Copyright © 2009, 2010, 2011, 2012 Axios, Inc. The U.S. Government has Unlimited Rights in this computer software pursuant to the appropriate DFARS clause. Any reproduction of this computer software, or portions thereof, marked with this legend must also reproduce these markings. Copyright © 2009, 2010, 2011, 2012 Rincon Research Corporation. The U.S. Government has Unlimited Rights in this computer software pursuant to the appropriate DFARS clause. Any reproduction of this computer software, or portions thereof, marked with this legend must also reproduce these markings. Copyright © 2010, 2011 Artemis Communications, LLC. The U.S. Government has Unlimited Rights in this computer software pursuant to the appropriate DFARS clause. Any reproduction of this computer software, or portions thereof, marked with this legend must also reproduce these markings. Copyright © 2009, 2010, 2011, 2012 Ventura Solutions, Inc. The U.S. Government has Unlimited Rights in this computer software pursuant to the appropriate DFARS clause. Any reproduction of this computer software, or portions thereof, marked with this legend must also reproduce these markings. Copyright © 2004, 2005, 2006, 2007, 2008 Virginia Polytechnic and State University Portions of this work are based on OSSIE. OSSIE is free software from Virginia Polytechnic and State University, distributed under the GNU Lesser General Public License (LGPL). Any reproduction of this computer software, or portions thereof, marked with this legend must also reproduce these markings. rest-python-2.0.0/LICENSE000066400000000000000000000167431245477330500150370ustar00rootroot00000000000000 GNU LESSER GENERAL PUBLIC LICENSE Version 3, 29 June 2007 Copyright (C) 2007 Free Software Foundation, Inc. Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed. This version of the GNU Lesser General Public License incorporates the terms and conditions of version 3 of the GNU General Public License, supplemented by the additional permissions listed below. 0. Additional Definitions. As used herein, "this License" refers to version 3 of the GNU Lesser General Public License, and the "GNU GPL" refers to version 3 of the GNU General Public License. "The Library" refers to a covered work governed by this License, other than an Application or a Combined Work as defined below. An "Application" is any work that makes use of an interface provided by the Library, but which is not otherwise based on the Library. Defining a subclass of a class defined by the Library is deemed a mode of using an interface provided by the Library. A "Combined Work" is a work produced by combining or linking an Application with the Library. The particular version of the Library with which the Combined Work was made is also called the "Linked Version". The "Minimal Corresponding Source" for a Combined Work means the Corresponding Source for the Combined Work, excluding any source code for portions of the Combined Work that, considered in isolation, are based on the Application, and not on the Linked Version. The "Corresponding Application Code" for a Combined Work means the object code and/or source code for the Application, including any data and utility programs needed for reproducing the Combined Work from the Application, but excluding the System Libraries of the Combined Work. 1. Exception to Section 3 of the GNU GPL. You may convey a covered work under sections 3 and 4 of this License without being bound by section 3 of the GNU GPL. 2. Conveying Modified Versions. If you modify a copy of the Library, and, in your modifications, a facility refers to a function or data to be supplied by an Application that uses the facility (other than as an argument passed when the facility is invoked), then you may convey a copy of the modified version: a) under this License, provided that you make a good faith effort to ensure that, in the event an Application does not supply the function or data, the facility still operates, and performs whatever part of its purpose remains meaningful, or b) under the GNU GPL, with none of the additional permissions of this License applicable to that copy. 3. Object Code Incorporating Material from Library Header Files. The object code form of an Application may incorporate material from a header file that is part of the Library. You may convey such object code under terms of your choice, provided that, if the incorporated material is not limited to numerical parameters, data structure layouts and accessors, or small macros, inline functions and templates (ten or fewer lines in length), you do both of the following: a) Give prominent notice with each copy of the object code that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the object code with a copy of the GNU GPL and this license document. 4. Combined Works. You may convey a Combined Work under terms of your choice that, taken together, effectively do not restrict modification of the portions of the Library contained in the Combined Work and reverse engineering for debugging such modifications, if you also do each of the following: a) Give prominent notice with each copy of the Combined Work that the Library is used in it and that the Library and its use are covered by this License. b) Accompany the Combined Work with a copy of the GNU GPL and this license document. c) For a Combined Work that displays copyright notices during execution, include the copyright notice for the Library among these notices, as well as a reference directing the user to the copies of the GNU GPL and this license document. d) Do one of the following: 0) Convey the Minimal Corresponding Source under the terms of this License, and the Corresponding Application Code in a form suitable for, and under terms that permit, the user to recombine or relink the Application with a modified version of the Linked Version to produce a modified Combined Work, in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source. 1) Use a suitable shared library mechanism for linking with the Library. A suitable mechanism is one that (a) uses at run time a copy of the Library already present on the user's computer system, and (b) will operate properly with a modified version of the Library that is interface-compatible with the Linked Version. e) Provide Installation Information, but only if you would otherwise be required to provide such information under section 6 of the GNU GPL, and only to the extent that such information is necessary to install and execute a modified version of the Combined Work produced by recombining or relinking the Application with a modified version of the Linked Version. (If you use option 4d0, the Installation Information must accompany the Minimal Corresponding Source and Corresponding Application Code. If you use option 4d1, you must provide the Installation Information in the manner specified by section 6 of the GNU GPL for conveying Corresponding Source.) 5. Combined Libraries. You may place library facilities that are a work based on the Library side by side in a single library together with other library facilities that are not Applications and are not covered by this License, and convey such a combined library under terms of your choice, if you do both of the following: a) Accompany the combined library with a copy of the same work based on the Library, uncombined with any other library facilities, conveyed under the terms of this License. b) Give prominent notice with the combined library that part of it is a work based on the Library, and explaining where to find the accompanying uncombined form of the same work. 6. Revised Versions of the GNU Lesser General Public License. The Free Software Foundation may publish revised and/or new versions of the GNU Lesser General Public License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. Each version is given a distinguishing version number. If the Library as you received it specifies that a certain numbered version of the GNU Lesser General Public License "or any later version" applies to it, you have the option of following the terms and conditions either of that published version or of any later version published by the Free Software Foundation. If the Library as you received it does not specify a version number of the GNU Lesser General Public License, you may choose any version of the GNU Lesser General Public License ever published by the Free Software Foundation. If the Library as you received it specifies that a proxy can decide whether future versions of the GNU Lesser General Public License shall apply, that proxy's public statement of acceptance of any version is permanent authorization for you to choose that version for the Library. rest-python-2.0.0/README.md000066400000000000000000000021151245477330500152750ustar00rootroot00000000000000# REDHAWK REST Python ## Description Contains the REDHAWK python implementation of the generic REST API ## REDHAWK Documentation REDHAWK Website: [www.redhawksdr.org](http://www.redhawksdr.org) ## Copyrights This work is protected by Copyright. Please refer to the [Copyright File](COPYRIGHT) for updated copyright information. ## License REDHAWK REST Python is licensed under the GNU Lesser General Public License (LGPL). ## Running For Development/Test environments there are scripts to automatically create a local environment and run the server. ./setup.sh install ./start.sh --port= The tools above will create a virtual environment in the current directory. For a more permanent solution, consult the `requirements.txt` and run the following command as a service: ./pyrest.py --port= `supervisord` is a common tool for running commands as a service and a sample configuration snippet can be found at `deploy/rest-python-supervisor.conf`. Once running the REST Interface can be tested at `http://localhost:/rh/rest/domains`. rest-python-2.0.0/deploy/000077500000000000000000000000001245477330500153135ustar00rootroot00000000000000rest-python-2.0.0/deploy/rest-python-nginx.conf000066400000000000000000000002621245477330500215770ustar00rootroot00000000000000location /redhawk/rest/ { proxy_set_header Host $host; proxy_pass http://localhost:9401; proxy_set_header Upgrade $http_upgrade; proxy_set_header Connection "Upgrade"; } rest-python-2.0.0/deploy/rest-python-supervisor.conf000066400000000000000000000016101245477330500226730ustar00rootroot00000000000000[program:redhawk-rest-python] command=/var/redhawk/web/rest-python/start.sh --port=9401 ; the program (relative uses PATH, can take args) user=redhawk ;priority=999 ; the relative start priority (default 999) autostart=true ; start at supervisord start (default: true) autorestart=true ; retstart at unexpected quit (default: true) stdout_logfile=/var/log/redhawk-web/rest-python.log ; stdout log path, NONE for none; default AUTO stdout_logfile_maxbytes=1MB ; max # logfile bytes b4 rotation (default 50MB) stdout_logfile_backups=10 ; # of stdout logfile backups (default 10) stderr_logfile=/var/log/redhawk-web/rest-python-error.log ; stderr log path, NONE for none; default AUTO stderr_logfile_maxbytes=1MB ; max # logfile bytes b4 rotation (default 50MB) stderr_logfile_backups=10 ; # of stderr logfile backups (default 10) rest-python-2.0.0/model/000077500000000000000000000000001245477330500151175ustar00rootroot00000000000000rest-python-2.0.0/model/__init__.py000066400000000000000000000015061245477330500172320ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # rest-python-2.0.0/model/_utils/000077500000000000000000000000001245477330500164165ustar00rootroot00000000000000rest-python-2.0.0/model/_utils/__init__.py000066400000000000000000000015111245477330500205250ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rtl-demo-app. # # REDHAWK rtl-demo-app is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rtl-demo-app is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # rest-python-2.0.0/model/_utils/tasking.py000066400000000000000000000105711245477330500204340ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rtl-demo-app. # # REDHAWK rtl-demo-app is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rtl-demo-app is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # from functools import wraps, partial from tornado import gen, concurrent from tornado import ioloop # Suppressed known DeprecationWarning for the futures backport import warnings, exceptions warnings.filterwarnings("ignore", "The futures package has been deprecated.*", exceptions.DeprecationWarning, "futures") import futures import logging import sys from futures import ThreadPoolExecutor EXECUTOR = ThreadPoolExecutor(100) _LINE = '%'*40 def safe_return_future(func): ''' Identical to tornado.gen.return_future plus thread safety. Executes the callback in the ioloop thread ''' @wraps(func) def exec_func(*args, **kwargs): future = concurrent.TracebackFuture() # accept optional callback callback = kwargs.pop('callback', None) if callback: future.add_done_callback(callback) try: io_loop = kwargs.pop('ioloop', None) if not io_loop: io_loop = ioloop.IOLoop.current() def _ioloop_callback(val): # print "set result to %s" % val future.set_result(val) def _callback(val): # set the result in the ioloop thread # print "callback val is %s " % val io_loop.add_callback(_ioloop_callback, val) # print "Func %s " % func func(callback=_callback, *args, **kwargs) except Exception: future.set_exc_info(sys.exc_info()) return future exec_func.__doc__ = \ ("%s\nsafe_return_future() wrapped function.\n" + "Runs asynchronously and returns a Future.\n" + "See _utils.concurrent for more info\n%s\n%s") % (_LINE, _LINE, exec_func.__doc__) return exec_func def background_task(func): @wraps(func) def exec_background(*args, **kwargs): ''' Executes a function in a background thread and returns a Future invoked when the thread completes. Useful for IO Bound processes that block. For CPU bound processes consider using celery, DO NOT execute CPU Bound tasks in the tornado process! io_loop is the optional ioloop used to invoke the callback in the processing thread. This is useful for unit tests that do not use the singleton ioloop. If set to none, IOLoop.current() is returned ''' # traceback future maintains python stack in exception future = concurrent.TracebackFuture() # use explicit ioloop for unit testing # Ref: https://github.com/tornadoweb/tornado/issues/663 io_loop = kwargs.pop('ioloop', None) if not io_loop: io_loop = ioloop.IOLoop.current() # accept optional callback callback = kwargs.pop('callback', None) if callback: future.add_done_callback(callback) def _do_task(*args, **kwargs): try: rtn = func(*args, **kwargs) io_loop.add_callback(future.set_result, rtn) except Exception, e: logging.debug("Callback exception", exc_info=True) io_loop.add_callback(future.set_exc_info, sys.exc_info()) EXECUTOR.submit(partial(_do_task, *args, **kwargs)) return future exec_background.__doc__ = \ ("%s\nbackground_task() wrapped function.\n" + "Runs asynchronously and returns a Future.\n" + "See _utils.concurrent for more info\n%s\n%s") % (_LINE, _LINE, exec_background.__doc__) return exec_background rest-python-2.0.0/model/_utils/test_concurrent.py000077500000000000000000000067711245477330500222270ustar00rootroot00000000000000#!/usr/bin/env python # # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rtl-demo-app. # # REDHAWK rtl-demo-app is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rtl-demo-app is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # import unittest import sys import logging import time from tornado import gen from tornado.testing import AsyncTestCase, LogTrapTestCase, main, gen_test from futures import ThreadPoolExecutor import tasking EXECUTOR = ThreadPoolExecutor(4) # all method returning suite is required by tornado.testing.main() def all(): return unittest.TestLoader().loadTestsFromModule(__import__(__name__)) class FuturesTest(AsyncTestCase): @tasking.background_task def _sleepfunc(self, input, duration=1, exception=False): logging.debug("_sleepfun start") time.sleep(duration) if exception: raise input logging.debug("_sleepfun end") return input @gen_test def test_background_future(self): ''' Runs a thread that sleeps in the background and generates a Future to indicate it's done or raised an exception. ''' f = yield self._sleepfunc("the input is 1", 1) logging.debug("The future is %s", f) self.assertEquals("the input is 1", f) @gen_test def test_background_future_except1(self): ''' Runs a thread that sleeps in the background and generates a Future to indicate it's done or raised an exception. ''' try: f = yield self._sleepfunc(ValueError('ignore me'), 1, exception=True) self.fail("Expecting ValueError") except ValueError: logging.info("Manual inspection of stack trace required:", exc_info=1) def test_background_future_exception(self): ''' Runs a thread that sleeps in the background and generates a Future to indicate it's done or raised an exception. ''' f = self._sleepfunc(ValueError('ignore me'), 1, exception=True) logging.debug("The future is %s", f) self.io_loop.add_future(f, self.stop) f2 = self.wait() # print "RESULT IS '%s'" % self.wait() self.assertEquals(ValueError, type(f2.exception())) @gen_test def test_callback_future(self): @tasking.safe_return_future def cbfunc(input, duration=1, callback=None): logging.debug("input=%s, callback=%s", input, callback) def background(i): logging.debug("invoking cbfunc") time.sleep(duration) callback(i) EXECUTOR.submit(background, input) f = yield cbfunc("the input is 1", 1) logging.debug("The future is %s", f) self.assertEquals("the input is 1", f) #TODO: Add tests for callback options if __name__ == '__main__': # to enable logging, use --logging=debug main() rest-python-2.0.0/model/domain.py000066400000000000000000000154061245477330500167460ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ REDHAWK Helper class used by the Server Handlers """ import logging from ossie.utils import redhawk from ossie.utils.redhawk.channels import ODMListener import traceback def scan_domains(): return redhawk.scan() class ResourceNotFound(Exception): def __init__(self, resource='resource', name='Unknown'): self.name = name self.resource = resource def __str__(self): return "Unable to find %s '%s'" % (self.resource, self.name) class WaveformLaunchError(Exception): def __init__(self, name='Unknown', msg=''): self.name = name self.msg = msg def __str__(self): return "Not able to launch waveform '%s'. %s" % (self.name, self.msg) class ApplicationReleaseError(Exception): def __init__(self, name='Unknown', msg=''): self.name = name self.msg = msg def __str__(self): return "Not able to release waveform '%s'. %s" % (self.name, self.msg) class Domain: domMgr_ptr = None odmListener = None eventHandlers = [] name = None def __init__(self, domainname): logging.trace("Estasblishing domain %s", domainname, exc_info=True) self.name = domainname try: self._establish_domain() except StandardError, e: logging.warn("Unable to find domain %s", e, exc_info=1) raise ResourceNotFound("domain", domainname) def _odm_response(self, event): for eventH in self.eventHandlers: eventH.event_queue.put(event) def _connect_odm_listener(self): self.odmListener = ODMListener() self.odmListener.connect(self.domMgr_ptr) self.odmListener.deviceManagerAdded.addListener(self._odm_response) self.odmListener.deviceManagerRemoved.addListener(self._odm_response) self.odmListener.applicationAdded.addListener(self._odm_response) self.odmListener.applicationRemoved.addListener(self._odm_response) def _establish_domain(self): redhawk.setTrackApps(False) self.domMgr_ptr = redhawk.attach(str(self.name)) self.domMgr_ptr.__odmListener = None self._connect_odm_listener() def properties(self): props = self.domMgr_ptr.query([]) # TODO: self.domMgr_ptr._properties return props def get_domain_info(self): if self.domMgr_ptr: return self.domMgr_ptr raise ResourceNotFound('domain', self.name) def find_app(self, app_id=None): _dom = self.get_domain_info() apps = _dom.apps if not app_id: return apps for app in apps: if app._get_identifier() == app_id: return app raise ResourceNotFound('application', app_id) def find_component(self, app_id, comp_id=None): app = self.find_app(app_id) if not comp_id: return app.comps for comp in app.comps: if comp._id == comp_id: return comp raise ResourceNotFound('component', comp_id) def find_device_manager(self, device_manager_id=None): _dom = self.get_domain_info() if not device_manager_id: return _dom.devMgrs for dev_mgr in _dom.devMgrs: if dev_mgr.id == device_manager_id: return dev_mgr raise ResourceNotFound('device manager', device_manager_id) def find_device(self, device_manager_id, device_id=None): dev_mgr = self.find_device_manager(device_manager_id) if not device_id: return dev_mgr.devs for dev in dev_mgr.devs: if dev._id == device_id: return dev raise ResourceNotFound('device', device_id) def find_service(self, device_manager_id, service_id=None): dev_mgr = self.find_device_manager(device_manager_id) if not service_id: return dev_mgr.services for svc in dev_mgr.services: if svc.id == service_id: return svc raise ResourceNotFound('service', service_id) def apps(self): apps_dict = [] apps = self.find_app() for app in apps: apps_dict.append({'name': app.name, 'id': app._get_identifier()}) return apps_dict def components(self, app_id): comps_dict = [] comps = self.find_component(app_id) for comp in comps: comps_dict.append({'name': comp.name, 'id': comp._get_identifier()}) return comps_dict def launch(self, app_name): _dom = self.get_domain_info() try: app = _dom.createApplication(app_name) return app._get_identifier() except Exception, e: raise WaveformLaunchError(app_name, str(e)) def release(self, app_id): app = self.find_app(app_id) try: app.releaseObject() return app_id except Exception, e: raise ApplicationReleaseError(app_id, str(e)) def available_apps(self): _dom = self.get_domain_info() sads_full_path = _dom.catalogSads() sads = _dom._sads sad_ret = [] for idx in range(len(sads)): sad_ret.append({'name': sads[idx], 'sad': sads_full_path[idx]}) return sad_ret def device_managers(self): if self.domMgr_ptr is None: raise ResourceNotFound('domain', self.name) dev_mgrs = self.domMgr_ptr.devMgrs dev_mgrs_dict = [] for dev_mgr in dev_mgrs: dev_mgrs_dict.append({'name': dev_mgr.name, 'id': dev_mgr.id}) return dev_mgrs_dict def devices(self, dev_mgr_id): devs = self.find_device(dev_mgr_id) ret_dict = [] for dev in devs: ret_dict.append({'name': dev.name, 'id': dev._id}) return ret_dict def services(self, dev_mgr_id): svcs = self.find_service(dev_mgr_id) ret_dict = [] for svc in svcs: ret_dict.append({'name': svc._instanceName, 'id': svc._refid}) return ret_dict rest-python-2.0.0/model/redhawk.py000066400000000000000000000132001245477330500171120ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ redhawk.py Asynchronous Tornado service for REDHAWK. Maps the functions in domain.py and caches the domain object. """ from _utils.tasking import background_task from domain import Domain, scan_domains, ResourceNotFound class Redhawk(object): __domains = {} def _get_domain(self, domain_name): name = str(domain_name) if not name in self.__domains: self.__domains[name] = Domain(domain_name) return self.__domains[name] ############################## # DOMAIN @background_task def get_domain_list(self): return scan_domains() @background_task def get_domain_info(self, domain_name): dom = self._get_domain(domain_name) return dom.get_domain_info() @background_task def get_domain_properties(self, domain_name): dom = self._get_domain(domain_name) return dom.properties() ############################## # APPLICATION @background_task def get_application(self, domain_name, app_id): dom = self._get_domain(domain_name) return dom.find_app(app_id) @background_task def get_application_list(self, domain_name): dom = self._get_domain(domain_name) return dom.apps() @background_task def get_available_applications(self, domain_name): dom = self._get_domain(domain_name) return dom.available_apps() @background_task def launch_application(self, domain_name, app_name): dom = self._get_domain(domain_name) return dom.launch(app_name) @background_task def release_application(self, domain_name, app_id): dom = self._get_domain(domain_name) return dom.release(app_id) ############################## # COMPONENT @background_task def get_component(self, domain_name, app_id, comp_id): dom = self._get_domain(domain_name) return dom.find_component(app_id, comp_id) @background_task def get_component_list(self, domain_name, app_id): dom = self._get_domain(domain_name) return dom.components(app_id) @background_task def component_configure(self, domain_name, app_id, comp_id, new_properties): dom = self._get_domain(domain_name) comp = dom.find_component(app_id, comp_id) configure_changes = {} for prop in comp._properties: if prop.id in new_properties: if new_properties[prop.id] != prop.queryValue(): configure_changes[prop.id] = (type(prop.queryValue()))(new_properties[prop.id]) return comp.configure(configure_changes) ############################## # DEVICE MANAGER @background_task def get_device_manager(self, domain_name, device_manager_id): dom = self._get_domain(domain_name) return dom.find_device_manager(device_manager_id) @background_task def get_device_manager_list(self, domain_name): dom = self._get_domain(domain_name) return dom.device_managers() ############################## # DEVICE @background_task def get_device_list(self, domain_name, device_manager_id): dom = self._get_domain(domain_name) return dom.devices(device_manager_id) @background_task def get_device(self, domain_name, device_manager_id, device_id): dom = self._get_domain(domain_name) return dom.find_device(device_manager_id, device_id) ############################## # SERVICE @background_task def get_service_list(self, domain_name, device_manager_id): dom = self._get_domain(domain_name) return dom.services(device_manager_id) ############################## # GENERIC @background_task def get_object_by_path(self, path, path_type): ''' Locates a redhawk object with the given path, and path type. Returns the object + remaining path: comp, opath = locate(ipath, 'component') Valid path types are: 'application' - [ domain id, application-id ] 'component' - [ domain id, application-id, component-id ] 'device-mgr' - [ domain id, device-manager-id ] 'device' - [ domain id, device-manager-id, device-id ] ''' domain = self._get_domain(path[0]) if path_type == 'application': return domain.find_app(path[1]), path[2:] elif path_type == 'component': return domain.find_component(path[1], path[2]), path[3:] elif path_type == 'device-mgr': return domain.find_device_manager(path[1]), path[2:] elif path_type == 'device': return domain.find_device(path[1], path[2]), path[3:] raise ValueError("Bad path type %s. Must be one of application, component, device-mgr or device" % path_type) rest-python-2.0.0/pyrest.py000077500000000000000000000130311245477330500157200ustar00rootroot00000000000000#!/usr/bin/env python # # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # import os from rest.domain import DomainInfo, DomainProperties from rest.application import Applications from rest.component import Component, ComponentProperties from rest.devicemanager import DeviceManagers from rest.device import Devices, DeviceProperties from rest.port import PortHandler from rest.bulkio_handler import BulkIOWebsocketHandler import tornado.httpserver import tornado.web import tornado.websocket from tornado import ioloop from model.redhawk import Redhawk # setup command line options from tornado.options import define, options define('port', default=8080, type=int, help="server port") define("debug", default=False, type=bool, help="Enable Tornado debug mode. Reloads code") _ID = r'/([^/]+)' _LIST = r'/?' _DOMAIN_PATH = r'/redhawk/rest/domains' _APPLICATION_PATH = _DOMAIN_PATH + _ID + r'/applications' _COMPONENT_PATH = _APPLICATION_PATH + _ID + r'/components' _DEVICE_MGR_PATH = _DOMAIN_PATH + _ID + r'/deviceManagers' _DEVICE_PATH = _DEVICE_MGR_PATH + _ID + r'/devices' _PROPERTIES_PATH = r'/properties' _PORT_PATH = r'/ports' _BULKIO_PATH = _PORT_PATH + _ID + r'/bulkio' class Application(tornado.web.Application): def __init__(self, *args, **kwargs): # explicit _ioloop for unit testing _ioloop = kwargs.get('_ioloop', None) cwd = os.path.abspath(os.path.dirname(__import__(__name__).__file__)) # REDHAWK Service redhawk = Redhawk() handlers = [ (r"/apps/(.*)/$", IndexHandler), (r"/apps/(.*)", tornado.web.StaticFileHandler, {"path": os.path.join(cwd, "apps")}), # Domains (_DOMAIN_PATH + _LIST, DomainInfo, dict(redhawk=redhawk)), (_DOMAIN_PATH + _ID, DomainInfo, dict(redhawk=redhawk)), (_DOMAIN_PATH + _ID + _PROPERTIES_PATH + _LIST, DomainProperties, dict(redhawk=redhawk)), (_DOMAIN_PATH + _ID + _PROPERTIES_PATH + _ID, DomainProperties, dict(redhawk=redhawk)), # Applications (_APPLICATION_PATH + _LIST, Applications, dict(redhawk=redhawk)), (_APPLICATION_PATH + _ID, Applications, dict(redhawk=redhawk)), (_APPLICATION_PATH + _ID + _PORT_PATH + _LIST, PortHandler, dict(redhawk=redhawk, kind='application')), (_APPLICATION_PATH + _ID + _PORT_PATH + _ID, PortHandler, dict(redhawk=redhawk, kind='application')), (_APPLICATION_PATH + _ID + _BULKIO_PATH, BulkIOWebsocketHandler, dict(redhawk=redhawk, kind='application', _ioloop=_ioloop)), # Components (_COMPONENT_PATH + _LIST, Component, dict(redhawk=redhawk)), (_COMPONENT_PATH + _ID, Component, dict(redhawk=redhawk)), (_COMPONENT_PATH + _ID + _PROPERTIES_PATH + _LIST, ComponentProperties, dict(redhawk=redhawk)), (_COMPONENT_PATH + _ID + _PROPERTIES_PATH + _ID, ComponentProperties, dict(redhawk=redhawk)), (_COMPONENT_PATH + _ID + _PORT_PATH + _LIST, PortHandler, dict(redhawk=redhawk, kind='component')), (_COMPONENT_PATH + _ID + _PORT_PATH + _ID, PortHandler, dict(redhawk=redhawk, kind='component')), (_COMPONENT_PATH + _ID + _BULKIO_PATH, BulkIOWebsocketHandler, dict(redhawk=redhawk, kind='component', _ioloop=_ioloop)), # Device Managers (_DEVICE_MGR_PATH + _LIST, DeviceManagers, dict(redhawk=redhawk)), (_DEVICE_MGR_PATH + _ID, DeviceManagers, dict(redhawk=redhawk)), # Devices (_DEVICE_PATH + _LIST, Devices, dict(redhawk=redhawk)), (_DEVICE_PATH + _ID, Devices, dict(redhawk=redhawk)), (_DEVICE_PATH + _ID + _PROPERTIES_PATH + _LIST, DeviceProperties, dict(redhawk=redhawk)), (_DEVICE_PATH + _ID + _PROPERTIES_PATH + _ID, DeviceProperties, dict(redhawk=redhawk)), (_DEVICE_PATH + _ID + _PORT_PATH + _LIST, PortHandler, dict(redhawk=redhawk, kind='device')), (_DEVICE_PATH + _ID + _PORT_PATH + _ID, PortHandler, dict(redhawk=redhawk, kind='device')), (_DEVICE_PATH + _ID + _BULKIO_PATH, BulkIOWebsocketHandler, dict(redhawk=redhawk, kind='device', _ioloop=_ioloop)), ] tornado.web.Application.__init__(self, handlers, *args, **kwargs) class IndexHandler(tornado.web.RequestHandler): def get(self, path): self.render("apps/"+path+"/index.html") def main(): tornado.options.parse_command_line() application = Application(debug=options.debug) application.listen(options.port) ioloop.IOLoop.instance().start() if __name__ == '__main__': main() rest-python-2.0.0/pyvenv000077500000000000000000000004641245477330500153000ustar00rootroot00000000000000#!/bin/sh # Absolute path to this script, e.g. /home/user/bin/foo.sh SCRIPT=$(readlink -f "$0") # Absolute path this script is in, thus /home/user/bin SCRIPTPATH=$(dirname "$SCRIPT") export VIRTUAL_ENV="${SCRIPTPATH}/.virtualenv" export PATH="$VIRTUAL_ENV/bin:$PATH" unset PYTHON_HOME exec "${@:-$SHELL}" rest-python-2.0.0/redhawk-rest-python.spec000066400000000000000000000047141245477330500206200ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK core. # # REDHAWK core is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK core is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # %define _prefix /var/redhawk/web %define _app %{_prefix}/rest-python %define _supervisor /etc/redhawk-web/supervisor.d %define _nginx /etc/nginx/conf.d/redhawk-sites Prefix: %{_prefix} Name: redhawk-rest-python Version: 2.0.0 Release: 1%{?dist} Summary: A REDHAWK REST application that exposes the entire domain. License: GPL BuildRoot: %(mktemp -ud %{_tmppath}/%{name}-%{version}-%{release}-XXXXXX) Source0: %{name}-%{version}.tar.gz Requires: python Requires: redhawk >= 1.10 Requires: redhawk-devel Requires: bulkioInterfaces Requires: redhawk-web Requires: rhweb-python-tornado Requires: python-futures %description %{summary} * Commit: __REVISION__ * Source Date/Time: __DATETIME__ %prep %setup -q %build %install mkdir -p $RPM_BUILD_ROOT%{_app} cp pyrest.py $RPM_BUILD_ROOT%{_app} mkdir -p $RPM_BUILD_ROOT%{_app}/model/_utils cp model/*.py $RPM_BUILD_ROOT%{_app}/model cp model/_utils/*.py $RPM_BUILD_ROOT%{_app}/model/_utils mkdir -p $RPM_BUILD_ROOT%{_app}/rest cp rest/*.py $RPM_BUILD_ROOT%{_app}/rest cp start.sh $RPM_BUILD_ROOT%{_app} mkdir -p $RPM_BUILD_ROOT%{_supervisor} cp deploy/rest-python-supervisor.conf $RPM_BUILD_ROOT%{_supervisor}/redhawk-rest-python.conf mkdir -p $RPM_BUILD_ROOT%{_nginx}/redhawk-sites cp deploy/rest-python-nginx.conf $RPM_BUILD_ROOT%{_nginx}/rest-python.enabled %clean rm -rf %{buildroot} %files %defattr(-,redhawk,redhawk,-) %dir %{_app} %{_app}/start.sh %{_app}/pyrest.py %{_app}/pyrest.pyc %{_app}/pyrest.pyo %{_app}/model %{_app}/model/_utils %{_app}/rest %defattr(-,root,root,-) %{_nginx}/rest-python.enabled %{_supervisor}/redhawk-rest-python.conf rest-python-2.0.0/requirements.txt000066400000000000000000000000361245477330500173020ustar00rootroot00000000000000tornado==4.0.2 futures==2.1.6 rest-python-2.0.0/rest/000077500000000000000000000000001245477330500147745ustar00rootroot00000000000000rest-python-2.0.0/rest/__init__.py000066400000000000000000000015311245477330500171050ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # __author__ = 'rxc' rest-python-2.0.0/rest/application.py000066400000000000000000000065541245477330500176630ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Rest handlers for Applications Classes: Applications -- Get info, launch and release """ from tornado import gen from handler import JsonHandler from helper import PropertyHelper, PortHelper import json class Applications(JsonHandler, PropertyHelper, PortHelper): @gen.coroutine def get(self, domain_name, app_id=None): if app_id: app = yield self.redhawk.get_application(domain_name, app_id) comps = yield self.redhawk.get_component_list(domain_name, app_id) info = { 'id': app._get_identifier(), 'name': app.name, 'started': app._get_started(), 'components': comps, 'ports': self.format_ports(app.ports), 'properties': self.format_properties(app._properties) } else: apps = yield self.redhawk.get_application_list(domain_name) wfs = yield self.redhawk.get_available_applications(domain_name) info = {'applications': apps, 'waveforms': wfs} self._render_json(info) @gen.coroutine def post(self, domain_name, app_id=None): data = json.loads(self.request.body) if app_id: app = yield self.redhawk.get_application(domain_name, app_id) started = data['started'] if started: app.start() else: app.stop() self._render_json({'id': app_id, 'started': app._get_started()}) else: app_name = str(data['name']) app_id = yield self.redhawk.launch_application(domain_name, app_name) apps = yield self.redhawk.get_application_list(domain_name) if 'started' in data and data['started']: app = yield self.redhawk.get_application(domain_name, app_id) app.start() self._render_json({'launched': app_id, 'applications': apps}) @gen.coroutine def put(self, domain_name, app_id=None): data = json.loads(self.request.body) app = yield self.redhawk.get_application(domain_name, app_id) started = data['started'] if started: app.start() else: app.stop() self._render_json({'id': app_id, 'started': app._get_started()}) @gen.coroutine def delete(self, domain_name, app_id): yield self.redhawk.release_application(domain_name, app_id) apps = yield self.redhawk.get_application_list(domain_name) self._render_json({'released': app_id, 'applications': apps}) rest-python-2.0.0/rest/asyncport.py000066400000000000000000000106011245477330500173660ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK core. # # REDHAWK core is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK core is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # import logging from new import classobj from bulkio.bulkioInterfaces import BULKIO, BULKIO__POA class AsyncPort(object): """ A port that uses callbacks for SRI and data. """ def __init__(self, porttype, pushSRI, pushPacket): """ Inputs: :porttype The BULKIO__POA data type """ self.port_type = porttype self.last_sri = BULKIO.StreamSRI(1, 0.0, 0.001, 1, 200, 0.0, 0.001, 1, 1, "defaultStreamID", True, []) self.last_packet = [] self.eos = False self._pushSRI_callback = pushSRI self._pushPacket_callback = pushPacket self._logger = logging.getLogger(self.__class__.__name__) def start(self): self.eos = False def _pushSRI(self, H): """ Stores the SteramSRI object regardless that there is no need for it Input: The StreamSRI object containing the information required to generate the header file """ self.last_sri = H try: self._pushSRI_callback(H) except Exception, e: self._logger.exception("PUSH SRI Failure") def _pushPacket(self, data, ts, EOS, stream_id): """ Appends the data to the end of the array. Input: The actual data to append to the array The timestamp Flag indicating if this is the End Of the Stream The unique stream id """ if EOS: self.eos = True self.last_packet = data try: self._pushPacket_callback(data, ts, EOS, stream_id) except Exception, e: self._logger.exception("PushPacket Failure ts=%s, EOS=%s, stream_id=%s, data=%d elements", ts, EOS, stream_id, len(data)) def getPort(self): """ Returns a Port object of the same type as the one specified as the porttype argument during the object instantiation. It uses the classobj from the new module to generate a class on runtime. The classobj generates a class using the following arguments: name: The name of the class to generate bases: A tuple containing all the base classes to use dct: A dictionary containing all the attributes such as functions, and class variables It is important to notice that the porttype is a BULKIO__POA type and not a BULKIO type. The reason is because it is used to generate a Port class that will be returned when the getPort() is invoked. The returned class is the one acting as a server and therefore must be a Portable Object Adapter rather and a simple BULKIO object. """ # The classobj generates a class using the following arguments: # # name: The name of the class to generate # bases: A tuple containing all the base classes to use # dct: A dictionary containing all the attributes such as # functions, and class variables PortClass = classobj('PortClass', (self.port_type,), {'pushPacket':self._pushPacket, 'pushSRI':self._pushSRI}) # Create a port using the generate Metaclass and return an instance port = PortClass() return port._this()rest-python-2.0.0/rest/bulkio_handler.py000066400000000000000000000123331245477330500203320ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # # system imports import logging from bulkio.bulkioInterfaces import BULKIO__POA # third party imports from tornado import ioloop, gen from tornado import websocket import numpy from model.domain import Domain, ResourceNotFound from asyncport import AsyncPort def _floats2bin(flist): """ Converts a list of python floating point values to a packed array of IEEE 754 32 bit floating point """ return numpy.array(flist).astype('float32').tostring() def _doubles2bin(flist): """ Converts a list of python floating point values to a packed array of IEEE 754 64 bit floating point """ return numpy.array(flist).astype('float64').tostring() def _pass_through(flist): return flist class BulkIOWebsocketHandler(websocket.WebSocketHandler): data_conversion_map = { 'dataFloat': _floats2bin, 'dataDouble': _doubles2bin, 'dataOctet': _pass_through, 'dataShort': _pass_through } def initialize(self, kind, redhawk=None, _ioloop=None): self.kind = kind self.redhawk = redhawk if not _ioloop: _ioloop = ioloop.IOLoop.current() self._ioloop = _ioloop @gen.coroutine def open(self, *args): try: logging.debug("BulkIOWebsocketHandler open kind=%s, path=%s", self.kind, args) obj, path = yield self.redhawk.get_object_by_path(args, path_type=self.kind) logging.debug("Found object %s", dir(obj)) for p in obj.ports: if p.name == path[0]: if p._direction == 'Uses': data_type = p._using.name namespace = p._using.nameSpace if namespace == 'BULKIO': self.port = obj.getPort(str(path[0])) logging.debug("Found port %s", self.port) self.converter = self.data_conversion_map[data_type] bulkio_poa = getattr(BULKIO__POA, data_type) logging.debug(bulkio_poa) self.async_port = AsyncPort(bulkio_poa, self._pushSRI, self._pushPacket) self._portname = 'myport%s' % id(self) self.port.connectPort(self.async_port.getPort(), self._portname) break else: raise ValueError("Port '%s' is not a BULKIO port" % path[0]) else: raise ValueError("Port '%s' is not a uses" % path[0]) else: raise ValueError("Could not find port of name '%s'" % path[0]) except ResourceNotFound, e: self.write_message(dict(error='ResourceNotFound', message=str(e))) self.close() except Exception, e: logging.exception('Error with request %s' % self.request.full_url()) self.write_message(dict(error='SystemError', message=str(e))) self.close() def on_message(self, message): logging.debug('stream message[%d]: %s', len(message), message) def on_close(self): logging.debug('Stream CLOSE') try: self.port.disconnectPort(self._portname) except Exception, e: logging.exception('Error disconnecting port %s' % self._portname) def _pushSRI(self, SRI): self._ioloop.add_callback(self.write_message, dict(hversion=SRI.hversion, xstart=SRI.xstart, xdelta=SRI.xdelta, xunits=SRI.xunits, subsize=SRI.subsize, ystart=SRI.ystart, ydelta=SRI.ydelta, yunits=SRI.yunits, mode=SRI.mode, streamID=SRI.streamID, blocking=SRI.blocking, keywords=dict(((kw.id, kw.value.value()) for kw in SRI.keywords)))) def _pushPacket(self, data, ts, EOS, stream_id): # FIXME: need to write ts, EOS and stream id self._ioloop.add_callback(self.write_message, self.converter(data), binary=True) def write_message(self, *args, **ioargs): # hide WebSocketClosedError because it's very likely try: super(BulkIOWebsocketHandler, self).write_message(*args, **ioargs) except websocket.WebSocketClosedError: logging.debug('Received WebSocketClosedError. Ignoring') rest-python-2.0.0/rest/component.py000066400000000000000000000045641245477330500173610ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Rest handlers for Components Classes: Component -- Get info about a specific component ComponentProperties -- Manipulate properties of a specific component """ from tornado import gen from handler import JsonHandler from helper import PropertyHelper, PortHelper import json class Component(JsonHandler, PropertyHelper, PortHelper): @gen.coroutine def get(self, domain_name, app_id, comp_id=None): if comp_id: comp = yield self.redhawk.get_component(domain_name, app_id, comp_id) info = { 'name': comp.name, 'id': comp._id, 'started': comp._get_started(), 'ports': self.format_ports(comp.ports), 'properties': self.format_properties(comp._properties) } else: comps = yield self.redhawk.get_component_list(domain_name, app_id) info = {'components': comps} self._render_json(info) class ComponentProperties(JsonHandler, PropertyHelper): @gen.coroutine def get(self, domain, application, component): comp = yield self.redhawk.get_component(domain, application, component) self._render_json({ 'properties': self.format_properties(comp._properties) }) @gen.coroutine def put(self, domain, application, component): data = json.loads(self.request.body) changes = {} for p in data['properties']: changes[p['id']] = p['value'] yield self.redhawk.component_configure(domain, application, component, changes) rest-python-2.0.0/rest/device.py000066400000000000000000000035611245477330500166120ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Rest handlers for Devices Classes: Device -- Get info of a specific device """ from tornado import gen from handler import JsonHandler from helper import PropertyHelper, PortHelper from tornado import web class Devices(JsonHandler, PropertyHelper, PortHelper): @gen.coroutine def get(self, domain_name, dev_mgr_id, dev_id=None): if dev_id: dev = yield self.redhawk.get_device(domain_name, dev_mgr_id, dev_id) info = { 'name': dev.name, 'id': dev._id, 'started': dev._get_started(), 'ports': self.format_ports(dev.ports), 'properties': self.format_properties(dev._properties) } else: devices = yield self.redhawk.get_device_list(domain_name, dev_mgr_id) info = {'devices': devices} self._render_json(info) class DeviceProperties(web.RequestHandler): def get(self, *args): self.set_status(500) self.write(dict(status='Device Properties handler not implemented')) rest-python-2.0.0/rest/devicemanager.py000066400000000000000000000037161245477330500201470ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Rest handlers for Device Managers Classes: DeviceManagers -- Get info of all or a specific device manager """ from tornado import gen from handler import JsonHandler from helper import PropertyHelper, PortHelper class DeviceManagers(JsonHandler, PropertyHelper, PortHelper): @gen.coroutine def get(self, domain_name, dev_mgr_id=None): if dev_mgr_id: dev_mgr = yield self.redhawk.get_device_manager(domain_name, dev_mgr_id) services = yield self.redhawk.get_service_list(domain_name, dev_mgr_id) devices = yield self.redhawk.get_device_list(domain_name, dev_mgr_id) # TODO: Find out why _properties is not in device manager prop_dict = self.format_properties(dev_mgr.query([])) info = { 'name': dev_mgr.name, 'id': dev_mgr.id, 'properties': prop_dict, 'devices': devices, 'services': services } else: managers = yield self.redhawk.get_device_manager_list(domain_name) info = {'deviceManagers': managers} self._render_json(info) rest-python-2.0.0/rest/domain.py000066400000000000000000000050111245477330500166120ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Rest handlers for Domains Classes: DomainInfo -- Get info of all or a specific domain DomainProperties -- Manipulate the properties of a domain """ from tornado import gen from handler import JsonHandler from helper import PropertyHelper class DomainInfo(JsonHandler, PropertyHelper): @gen.coroutine def get(self, domain_name=None): if domain_name: dom_info = yield self.redhawk.get_domain_info(domain_name) properties = yield self.redhawk.get_domain_properties(domain_name) apps = yield self.redhawk.get_application_list(domain_name) device_managers = yield self.redhawk.get_device_manager_list(domain_name) info = { 'id': dom_info._get_identifier(), 'name': dom_info.name, 'properties': self.format_properties(properties), 'applications': apps, 'deviceManagers': device_managers } else: domains = yield self.redhawk.get_domain_list() info = {'domains': domains} self._render_json(info) class DomainProperties(JsonHandler, PropertyHelper): @gen.coroutine def get(self, domain_name, prop_name=None): properties = yield self.redhawk.get_domain_properties(domain_name) info = self.format_properties(properties) if prop_name: value = None for item in info: if item['name'] == prop_name: value = item if value: self._render_json(value) else: self._render_json({'error': "Could not find property"}) else: self._render_json({'properties': info}) rest-python-2.0.0/rest/handler.py000066400000000000000000000037561245477330500167760ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Rest handlers Classes: JsonHandler -- Handle generic functions of a json rest interface """ import logging import tornado.web from model.domain import ResourceNotFound class JsonHandler(tornado.web.RequestHandler): redhawk = None def initialize(self, redhawk): self.redhawk = redhawk def _handle_request_exception(self, e): logging.error('Exception:: %s', e, exc_info=1) status = 500 resp = {'message': str(e), 'error': type(e).__name__} if type(e) == ResourceNotFound: status = 404 elif type(e) == KeyError: resp = {'error': 'JsonParsing', 'message': "Expecting value "+str(e)} elif type(e) == ValueError: resp = {'error': 'JsonParsing', 'message': str(e)} self._render_error(resp, status) def _render_json(self, resp): if resp and not 'error' in resp: self.set_header("Content-Type", "application/json; charset='utf-8'") self.write(resp) else: self._render_error("Unable to find requested resource", 404) def _render_error(self, msg, status=500): self.set_status(status) self.finish(msg) rest-python-2.0.0/rest/helper.py000066400000000000000000000106551245477330500166340ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Provides static classes to format for REST Classes: PropertyHelper -- Convert CORBA and RH Sandbox Properties into dictionaries (more descriptive than prop_to_dict) PortHelper -- Convert Port information into dict """ from ossie.utils.prop_helpers import Property class PropertyHelper(object): @staticmethod def format_properties(properties): if not properties: return [] elif any(isinstance(p, Property) for p in properties): return PropertyHelper._property_set(properties) else: return PropertyHelper._corba_properties(properties) @staticmethod def _corba_properties(properties): prop_dict = [] for prop in properties: ret = PropertyHelper.__any(prop.value) ret['id'] = prop.id prop_dict.append(ret) return prop_dict @staticmethod def _property_set(properties): prop_dict = [] for prop in properties: if prop.type != 'struct' and prop.type != 'structSeq': if isinstance(prop.queryValue(), list): prop_type = "simpleSeq" else: prop_type = 'simple' else: prop_type = prop.type prop_json = { 'id': prop.id, 'name': prop.clean_name, 'value': prop.queryValue(), 'scaType': prop_type, 'mode': prop.mode, 'kinds': prop.kinds } if prop_type == 'simple': prop_json['type'] = type(prop.queryValue()).__name__ if prop_json['type'] == 'str': prop_json['type'] = 'string' elif prop_json['type'] == 'bool': prop_json['type'] = 'boolean' if '_enums' in dir(prop) and prop._enums: prop_json['enumerations'] = prop._enums prop_dict.append(prop_json) return prop_dict ############################################### # Private @staticmethod def __any_simple(corba_any): return {'scaType': 'simple', 'value': corba_any._v} @staticmethod def __any_struct(corba_any): ret = {'scaType': 'struct'} value = {} for a in corba_any._v: value[a.id] = a.value._v ret['value'] = value return ret @staticmethod def __any_seq(corba_any): ret = {'scaType': 'seq', 'value': []} for a in corba_any._v: ret['value'].append(PropertyHelper.__any(a)) return ret @staticmethod def __any(corba_any): type_name = str(corba_any._t) if 'CORBA.TypeCode("IDL:CF/Properties:1.0")' == type_name: return PropertyHelper.__any_struct(corba_any) elif 'CORBA.TypeCode("IDL:omg.org/CORBA/AnySeq:1.0")' == type_name: return PropertyHelper.__any_seq(corba_any) else: return PropertyHelper.__any_simple(corba_any) class PortHelper(object): @staticmethod def format_ports(ports): return [PortHelper.format_port(port) for port in ports] @staticmethod def format_port(port): port_value = {'name': port.name, 'direction': port._direction} if port._direction == 'Uses': version_idx = port._using.repoId.rfind(':') version = port._using.repoId[version_idx:] port_value['repId'] = port._using.repoId port_value['idl'] = { 'type': port._using.name, 'namespace': port._using.nameSpace, 'version': version } return port_value rest-python-2.0.0/rest/port.py000066400000000000000000000046671245477330500163470ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Rest handlers for Ports """ import logging from tornado import web, ioloop from helper import PortHelper from model.domain import ResourceNotFound from tornado import gen import json from handler import JsonHandler from helper import PropertyHelper class PortHandler(JsonHandler, PropertyHelper, PortHelper): def initialize(self, kind, redhawk=None, _ioloop=None): super(PortHandler, self).initialize(redhawk) self.kind = kind if not _ioloop: _ioloop = ioloop.IOLoop.current() self._ioloop = _ioloop @gen.coroutine def get(self, *args): try: logging.debug("port kind=%s, path=%s", self.kind, args) obj, path = yield self.redhawk.get_object_by_path(args, path_type=self.kind) logging.debug("Found object %s", dir(obj)) if path: name = path[0] for port in obj.ports: if port.name == name: self.write(json.dumps(self.format_port(port))) break else: raise ResourceNotFound('port', name) else: self.write(json.dumps(self.format_ports(obj.ports))) except ResourceNotFound, e: logging.debug('Resource not found %s' % str(e), exc_info=1) self.set_status(404) self.write(dict(error='ResourceNotFound', message=str(e))) except Exception, e: logging.exception('Error with request %s' % self.request.full_url()) self.set_status(500) self.write(dict(error='SystemError', message=str(e))) rest-python-2.0.0/setup.sh000077500000000000000000000027101245477330500155160ustar00rootroot00000000000000#!/bin/sh # # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # # Absolute path to this script, e.g. /home/user/bin/foo.sh SCRIPT=$(readlink -f "$0") # Absolute path this script is in, thus /home/user/bin SCRIPTPATH=$(dirname "$SCRIPT") venv="${SCRIPTPATH}/.virtualenv" pyvenv=${SCRIPTPATH}/pyvenv case "$1" in install) if [ -d $venv ]; then echo "Removing old python virtualenv" rm -rf ${venv} fi virtualenv --system-site-packages ${venv} ${pyvenv} pip install -r requirements.txt ;; uninstall) if [ -d $venv ]; then echo "Removing old python virtualenv" rm -rf ${venv} fi ;; *) echo "Usage: $0 {install|uninstall}" ;; esac rest-python-2.0.0/start.sh000077500000000000000000000022651245477330500155200ustar00rootroot00000000000000#!/bin/sh # # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # # Absolute path to this script, e.g. /home/user/bin/foo.sh SCRIPT=$(readlink -f "$0") # Absolute path this script is in, thus /home/user/bin SCRIPTPATH=$(dirname "$SCRIPT") pyvenv="${SCRIPTPATH}/pyvenv" if [ ! -f ${pyvenv} ]; then pyvenv=/var/redhawk/web/bin/pyvenv fi source /etc/profile.d/redhawk.sh exec ${pyvenv} python ${SCRIPTPATH}/pyrest.py $@ rest-python-2.0.0/test.py000066400000000000000000000020121245477330500153430ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # from tornado.testing import main import unittest from tests import * def all(): return unittest.TestLoader().loadTestsFromModule(__import__(__name__)) if __name__ == '__main__': main() rest-python-2.0.0/test.sh000077500000000000000000000022261245477330500153370ustar00rootroot00000000000000#!/bin/sh # # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # # Absolute path to this script, e.g. /home/user/bin/foo.sh SCRIPT=$(readlink -f "$0") # Absolute path this script is in, thus /home/user/bin SCRIPTPATH=$(dirname "$SCRIPT") pyvenv="${SCRIPTPATH}/pyvenv" source /etc/profile.d/redhawk.sh # Clear virtual env ./setup.sh install exec ${pyvenv} python ${SCRIPTPATH}/test.py $@ rest-python-2.0.0/tests/000077500000000000000000000000001245477330500151615ustar00rootroot00000000000000rest-python-2.0.0/tests/__init__.py000066400000000000000000000026701245477330500172770ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ TestCases for the REST API Classes: DomainTests -- /domain ApplicationTests -- /domain/{NAME}/applications ComponentTests -- /domain/{NAME}/applications/{ID}/components DeviceManagerTests -- /domain/{NAME}/deviceManagers DeviceTests -- /domain/{NAME}/deviceManagers/{ID}/devices """ __author__ = 'rpcanno' from defaults import Default from domain import DomainTests from devicemanager import DeviceManagerTests from device import DeviceTests from application import ApplicationTests from component import ComponentTests from bulkio import BulkIOTests from port import PortTests from concurrent import ConcurrencyTests rest-python-2.0.0/tests/application.py000066400000000000000000000136201245477330500200400ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Tornado tests for the /domain/{NAME}/applications portion of the REST API """ import pprint import tornado from base import JsonTests from defaults import Default from model.redhawk import Redhawk class ApplicationTests(JsonTests): def setUp(self): super(ApplicationTests, self).setUp(); self.redhawk = Redhawk() def tearDown(self): # kill SigTest waveforms url = '/domains/'+Default.DOMAIN_NAME json, resp = self._json_request(url, 200) if 'applications' not in json: json['applications'] = [] for a in json['applications']: if a['name'].startswith('SigTest'): self._json_request( '/domains/'+Default.DOMAIN_NAME+'/applications/'+a['id'], 200, 'DELETE' ) super(ApplicationTests, self).tearDown(); @tornado.gen.coroutine def _get_applications(self): url = '/domains/'+Default.DOMAIN_NAME json, resp = yield self._async_json_request(url, 200) self.assertTrue('applications' in json) raise tornado.gen.Return((url, json['applications'])) @tornado.gen.coroutine def _launch(self, name): json, resp = yield self._async_json_request( '/domains/'+Default.DOMAIN_NAME+'/applications', 200, 'POST', {'name': name} ) self.assertTrue('launched' in json) self.assertTrue('applications' in json) self.assertTrue(json['launched'] in [x['id'] for x in json['applications']]) raise tornado.gen.Return(json['launched']) @tornado.gen.coroutine def _release(self, wf_id): json, resp = yield self._async_json_request( '/domains/'+Default.DOMAIN_NAME+'/applications/'+wf_id, 200, 'DELETE' ) self.assertAttr(json, 'released', wf_id) self.assertTrue('applications' in json) self.assertFalse(json['released'] in json['applications']) raise tornado.gen.Return(resp) @tornado.testing.gen_test def test_launch_release(self): url, applications = yield self._get_applications() json, resp = yield self._async_json_request(url+'/applications', 200) self.assertTrue('waveforms' in json) self.assertTrue(Default.WAVEFORM in [x['name'] for x in json['waveforms']]) wf_id = yield self._launch(Default.WAVEFORM) yield self._release(wf_id) @tornado.testing.gen_test def test_list(self): url, applications = yield self._get_applications() json, resp = yield self._async_json_request(url+'/applications', 200) self.assertTrue('waveforms' in json) self.assertTrue(isinstance(json['waveforms'], list)) for app in json['waveforms']: self.assertTrue('sad' in app) self.assertTrue('name' in app) self.assertIdList(json, 'applications') self.assertEquals(applications, json['applications']) @tornado.testing.gen_test def test_info(self): wf_id = yield self._launch(Default.WAVEFORM) url = '/domains/%s/applications/%s' % (Default.DOMAIN_NAME, wf_id) json, resp = yield self._async_json_request(url, 200) self.assertList(json, 'ports') self.assertList(json, 'components') self.assertTrue('name' in json) self.assertAttr(json, 'id', wf_id) self.assertList(json, 'properties') # TODO: self.assertProperties(json['properties']) @tornado.testing.gen_test def test_detect_new_applications(self): yield [ self.detect_new_applications() for x in xrange(10) ] @tornado.gen.coroutine def detect_new_applications(self): 'Test when an application started' url, apps = yield self._get_applications() # start a new app id = yield self.redhawk.launch_application(Default.DOMAIN_NAME, Default.WAVEFORM) # yield self._async_sleep(.5) # ensure it exists in the application url, apps2 = yield self._get_applications() if id not in (a['id'] for a in apps2): self.fail("Expecting %s in domain %s" % (id, Default.DOMAIN_NAME)) # if (len(apps)+1 != len(apps2)): # self.fail("Expecting one additional app %s %s" % (apps, apps2)) # now release it yield self.redhawk.release_application(Default.DOMAIN_NAME, id) # ensure it is missing in the application list url, apps3 = yield self._get_applications() if id in (a['id'] for a in apps3): self.fail("Not Expecting %s in domain %s" % (id, Default.DOMAIN_NAME)) # if (len(apps) != len(apps3)): # self.fail("Expecting same number of apps %s %s" % (apps, apps3)) @tornado.testing.gen_test def test_not_found(self): url = '/domains/%s/applications/adskfhsdhfasdhjfhsd' %Default.DOMAIN_NAME json, resp = yield self._async_json_request(url, 404) self._resource_not_found(json) rest-python-2.0.0/tests/base.py000066400000000000000000000221371245477330500164520ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Base TestCase class with convenience functions """ __author__ = 'rpcanno' import itertools import time from tornado.testing import AsyncHTTPTestCase from tornado.httpclient import AsyncHTTPClient, HTTPRequest, HTTPResponse, HTTPError, _RequestProxy from tornado.simple_httpclient import SimpleAsyncHTTPClient from pyrest import Application from tornado import gen from tornado import httputil, stack_context from tornado.concurrent import TracebackFuture import json from defaults import Default class MyAsyncHTTPClient(SimpleAsyncHTTPClient): ''' Adds a raise_error flag to fetch() to avoid exceptions when fetching a non-200 based response code. This code is from the latest 4.x tornado which has not been released ''' def fetch(self, request, callback=None, raise_error=True, **kwargs): """Executes a request, asynchronously returning an `HTTPResponse`. The request may be either a string URL or an `HTTPRequest` object. If it is a string, we construct an `HTTPRequest` using any additional kwargs: ``HTTPRequest(request, **kwargs)`` This method returns a `.Future` whose result is an `HTTPResponse`. By default, the ``Future`` will raise an `HTTPError` if the request returned a non-200 response code. Instead, if ``raise_error`` is set to False, the response will always be returned regardless of the response code. If a ``callback`` is given, it will be invoked with the `HTTPResponse`. In the callback interface, `HTTPError` is not automatically raised. Instead, you must check the response's ``error`` attribute or call its `~HTTPResponse.rethrow` method. """ if self._closed: raise RuntimeError("fetch() called on closed AsyncHTTPClient") if not isinstance(request, HTTPRequest): request = HTTPRequest(url=request, **kwargs) # We may modify this (to add Host, Accept-Encoding, etc), # so make sure we don't modify the caller's object. This is also # where normal dicts get converted to HTTPHeaders objects. request.headers = httputil.HTTPHeaders(request.headers) request = _RequestProxy(request, self.defaults) future = TracebackFuture() if callback is not None: callback = stack_context.wrap(callback) def handle_future(future): exc = future.exception() if isinstance(exc, HTTPError) and exc.response is not None: response = exc.response elif exc is not None: response = HTTPResponse( request, 599, error=exc, request_time=time.time() - request.start_time) else: response = future.result() self.io_loop.add_callback(callback, response) future.add_done_callback(handle_future) def handle_response(response): if raise_error and response.error: future.set_exception(response.error) else: future.set_result(response) self.fetch_impl(request, handle_response) return future class JsonAssertions(object): RESPONSE_CODES_2XX = (200, 201, 202, 203, 204, 205, 206) RESPONSE_CODES_3XX = (300, 301, 302, 303, 304, 305, 306, 307) RESPONSE_CODES_4XX = (400, 401, 402, 403, 404, 405, 406, 407, 408, 409, 410, 411, 412, 413, 414, 415, 416, 417) RESPONSE_CODES_5XX = (500, 501, 502, 503, 504, 505) def assertResponse(self, response, codes=RESPONSE_CODES_2XX): ''' Asserts a valid response Codes can be a set of codes (e.g. 2XX) or a single code ''' try: if response.code not in codes: self.fail("Response code %d not one of %s", response.code, codes) except TypeError: if response.code != codes: self.fail("Response code %d is not %s", response.code, codes) def assertJson(self, response): try: return json.loads(response.body) except ValueError: self.fail("Unable to parse json input '%s'" % response.body) def assertJsonResponse(self, response, codes=RESPONSE_CODES_2XX): data = assertJson(response) assertResponse(response, codes) return data def assertAttr(self, data, name, value): self.assertTrue(name in data) self.assertEquals(data[name], value) def assertList(self, data, name): self.assertTrue(name in data) self.assertTrue(isinstance(data[name], list)) def assertIdList(self, data, name): self.assertList(data, name) for item in data[name]: self.assertTrue('id' in item) self.assertTrue('name' in item) def assertProperties(self, data): self.assertTrue(isinstance(data, list)) for prop in data: self.assertList(prop, 'kinds') self.assertTrue('name' in prop) self.assertTrue('value' in prop) self.assertTrue('scaType' in prop) self.assertTrue('mode' in prop) self.assertTrue('type' in prop) self.assertTrue('id' in prop) class JsonTests(AsyncHTTPTestCase, JsonAssertions): def get_app(self): return Application() def _json_request(self, url, code, method='GET', json_data=None): body = None if json_data: body = json.dumps(json_data) AsyncHTTPClient(self.io_loop).fetch(self.get_url(Default.REST_BASE+url), self.stop, method=method, body=body) response = self.wait() self.assertEquals(code, response.code) data = {} if response.body: data = json.loads(response.body) return data, response @gen.coroutine def _async_json_request(self, url, code, method='GET', json_data=None): ''' Like _json_request, but yields a future Use like: @tornado.testing.gen_test test_foo(self): json, resp = yield_async_json_request('foo/bar') self.assertEquals('bar', json['value']) ''' body = None if json_data: body = json.dumps(json_data) response = yield MyAsyncHTTPClient(self.io_loop).fetch(self.get_url(Default.REST_BASE+url), self.stop, method=method, body=body, raise_error=False) self.assertEquals(code, response.code) data = {} if response.body: data = json.loads(response.body) raise gen.Return((data, response)) @gen.coroutine def _async_set_property(self, comp_id, d={}, **kwargs): ''' resp = yield _async_set_property(id, name=value, name=value) or resp = yield _async_set_property(id, {'foo:bar': 123}) ''' json, resp = yield self._async_json_request( "%s/components/%s/properties" % (self.base_url, comp_id), 200, 'PUT', {'properties': [ {'id': p[0], 'value': p[1]} for p in itertools.chain(d.items(), kwargs.items()) ]} ) raise gen.Return(resp) @gen.coroutine def _async_get_properties(self, comp_id): ''' Gets the properties asynchronously. Properties is a dictionary of the returned properties. properties, resp = yield _async_get_properties(comp_id) ''' json, resp = yield self._async_json_request("%s/components/%s/properties" % (self.base_url, comp_id), 200) raise gen.Return((dict((p["id"], p["value"]) for p in json['properties']), resp)) @gen.coroutine def _async_sleep(self, seconds): ''' Sleeps this request in the ioloop for seconds seconds. Usage: yield task1() yield _async_sleep(.5) yield task2() ''' yield gen.Task(self.io_loop.add_timeout, time.time() + seconds) def _resource_not_found(self, body): self.assertTrue('error' in body) self.assertEquals(body['error'], Default.RESOURCE_NOT_FOUND_ERR) self.assertTrue('message' in body) self.assertTrue(Default.RESOURCE_NOT_FOUND_MSG_REGEX.match(body['message'])) rest-python-2.0.0/tests/bulkio.py000077500000000000000000000103221245477330500170210ustar00rootroot00000000000000#!/usr/bin/env python # # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # # system imports import unittest import json import logging import time import threading from functools import partial # tornado imports import tornado import tornado.testing from tornado.testing import AsyncHTTPTestCase, LogTrapTestCase from tornado.httpclient import AsyncHTTPClient, HTTPRequest from tornado import websocket, gen # application imports from pyrest import Application from base import JsonTests from defaults import Default # all method returning suite is required by tornado.testing.main() #def all(): # return unittest.TestLoader().loadTestsFromModule(__import__(__name__)) class BulkIOTests(JsonTests, AsyncHTTPTestCase, LogTrapTestCase): # def setUp(self): # super(RESTfulTest, self).setUp() # rtl_app.RTLApp('REDHAWK_DEV').stop_survey() def setUp(self): super(JsonTests, self).setUp() json, resp = self._json_request( '/domains/%s/applications' % Default.DOMAIN_NAME, 200, 'POST', {'name': Default.WAVEFORM, 'started': True } ) self.assertTrue('launched' in json) self.base_url = '/domains/%s/applications/%s' % (Default.DOMAIN_NAME, json['launched']) json, resp = self._json_request(self.base_url, 200) self.assertList(json, 'components') self.assertTrue(json['components']) self.components = json['components'] def tearDown(self): self._json_request( self.base_url, 200, 'DELETE' ) super(BulkIOTests, self).tearDown() def get_app(self): return Application(debug=True, _ioloop=self.io_loop) @tornado.testing.gen_test def test_bulkio_ws(self): # NOTE: A timeout means the website took too long to respond # it could mean that bulkio port is not sending data cid = next((cp['id'] for cp in self.components if cp['name'] == 'SigGen'), None) if not cid: self.fail('Unable to find SigGen component') url = self.get_url("%s/components/%s/ports/out/bulkio"%(Default.REST_BASE+self.base_url,cid)).replace('http','ws') conn1 = yield websocket.websocket_connect(url, io_loop=self.io_loop) foundSRI = False for x in xrange(10): msg = yield conn1.read_message() try: data = json.loads(msg) logging.debug("Got SRI %s", data) foundSRI = True props = set(('hversion', 'xstart', 'xdelta', 'xunits', 'subsize', 'ystart', 'ydelta', 'yunits', 'mode', 'streamID', 'blocking', 'keywords')) missing = props.difference(data.keys()) if missing: self.fail("Missing SRI properties %s" % missing) except ValueError: data = dict(data=msg) if data.get('error', None): self.fail('Recieved websocket error %s' % data) #conn1.protocol.close() conn1.close() # wait a little bit to force close to take place in ioloop # (if we return without waiting, ioloop closes before websocket closes) x = yield gen.Task(self.io_loop.add_timeout, time.time() + .5) if not foundSRI: self.fail('Did not receive SRI') if __name__ == '__main__': tornado.testing.main() rest-python-2.0.0/tests/component.py000066400000000000000000000074651245477330500175510ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Tornado tests for the /domain/{NAME}/applications/{ID}/components portion of the REST API """ from pyrest import Application from base import JsonTests from defaults import Default class ComponentTests(JsonTests): def setUp(self): super(ComponentTests, self).setUp() json, resp = self._json_request( '/domains/%s/applications' % Default.DOMAIN_NAME, 200, 'POST', {'name': Default.WAVEFORM} ) self.assertTrue('launched' in json) self.base_url = '/domains/%s/applications/%s' % (Default.DOMAIN_NAME, json['launched']) json, resp = self._json_request(self.base_url, 200) self.assertList(json, 'components') self.assertTrue(json['components']) self.components = json['components'] def tearDown(self): self._json_request( self.base_url, 200, 'DELETE' ) super(ComponentTests, self).tearDown() def _get_comps(self): pass def test_list(self): json, resp = self._json_request(self.base_url + '/components', 200) self.assertIdList(json, 'components') self.assertEquals(self.components, json['components']) def test_info(self): comp_id = self.components[0]['id'] json, resp = self._json_request('%s/components/%s' % (self.base_url, comp_id), 200) self.assertList(json, 'ports') self.assertAttr(json, 'id', comp_id) self.assertAttr(json, 'name', Default.COMPONENT) self.assertList(json, 'properties') self.assertProperties(json['properties']) def test_not_found(self): json, resp = self._json_request('%s/components/ggsdfgfdg' % self.base_url, 404) self._resource_not_found(json) def test_properties(self): comp_id = self.components[0]['id'] json, resp = self._json_request('%s/components/%s' % (self.base_url, comp_id), 200) properties = json['properties'] json, resp = self._json_request("%s/components/%s/properties" % (self.base_url, comp_id), 200) self.assertList(json, 'properties') self.assertEquals(properties, json['properties']) prop = None for p in json['properties']: if p['id'] == Default.COMPONENT_PROPERTY: prop = p self.assertEquals(prop['value'], Default.COMPONENT_PROPERTY_VALUE) # Configure json, resp = self._json_request( "%s/components/%s/properties" % (self.base_url, comp_id), 200, 'PUT', {'properties': [ {'id': Default.COMPONENT_PROPERTY, 'value': Default.COMPONENT_PROPERTY_CHANGE} ]} ) json, resp = self._json_request("%s/components/%s/properties" % (self.base_url, comp_id), 200) prop = None for p in json['properties']: if p['id'] == Default.COMPONENT_PROPERTY: prop = p self.assertEquals(prop['value'], Default.COMPONENT_PROPERTY_CHANGE) rest-python-2.0.0/tests/concurrent.py000066400000000000000000000122161245477330500177170ustar00rootroot00000000000000""" Tornado tests for the /domain/{NAME}/applications/{ID}/components portion of the REST API """ # tornado imports import random import time import tornado import tornado.testing from tornado.testing import AsyncHTTPTestCase, LogTrapTestCase from tornado.httpclient import AsyncHTTPClient, HTTPRequest from tornado import websocket from pyrest import Application from base import JsonTests from defaults import Default import pprint class ConcurrencyTests(JsonTests): def setUp(self): super(ConcurrencyTests, self).setUp() json, resp = self._json_request( '/domains/%s/applications' % Default.DOMAIN_NAME, 200, 'POST', {'name': Default.WAVEFORM} ) self.assertTrue('launched' in json) self.base_url = '/domains/%s/applications/%s' % (Default.DOMAIN_NAME, json['launched']) json, resp = self._json_request(self.base_url, 200) self.assertList(json, 'components') self.assertTrue(json['components']) self.components = json['components'] def tearDown(self): self._json_request( self.base_url, 200, 'DELETE' ) super(ConcurrencyTests, self).tearDown() def _get_comps(self): pass @tornado.testing.gen_test(timeout=600) def test_list(self): http_client = AsyncHTTPClient() url = self.get_url(Default.REST_BASE + self.base_url + '/components') # Do five tests, get the average time times = [] avgs = {} for x in xrange(5): result1 = yield http_client.fetch(url) self.assertEquals(200, result1.code) times.append(result1.request_time) print result1.request_time avg = sum(times) / len(times) avgs[1] = avg print "AVG: %f" % avg clients = 10 results = yield [ http_client.fetch(url) for x in xrange(clients) ] avg1 = sum((r.request_time for r in results)) / len(results) avgs[clients] = avg1 print avg1 clients = 100 results = yield [ http_client.fetch(url) for x in xrange(clients) ] avg2 = sum((r.request_time for r in results)) / len(results) avgs[clients] = avg2 print avg2 clients = 200 results = yield [ http_client.fetch(url) for x in xrange(clients) ] avg3 = sum((r.request_time for r in results)) / len(results) avgs[clients] = avg3 print avg3 print "Averages ", avgs @tornado.gen.coroutine def set_properties2(self): ''' Updates the frequency to frequency + 10. Returns the cumulative time it took ''' yield tornado.gen.Task(self.io_loop.add_timeout, time.time() + random.random()) comp_id = self.components[0]['id'] properties, resp1 = yield self._async_get_properties(comp_id) print properties resp2 = yield self._async_set_property(comp_id, frequency=properties['frequency'] + 10) properties, resp3 = yield self._async_get_properties(comp_id) print properties # pprint.pprint(dict(resp1=resp1, resp2=resp2, resp3=resp3)) raise tornado.gen.Return(resp1.request_time + resp2.request_time + resp3.request_time) @tornado.testing.gen_test(timeout=600) def test_set_properties(self): values = yield [ self.set_properties2() for x in xrange(1) ] print values print "Average: %f" % (sum(values) / len(values)) values = yield [ self.set_properties2() for x in xrange(100) ] print values print "Average: %f" % (sum(values) / len(values)) # comp_id = self.components[0]['id'] # json, resp = yield self._async_json_request('%s/components/%s' % (self.base_url, comp_id), 200) # properties = json['properties'] # # json, resp = yield self._async_json_request("%s/components/%s/properties" % (self.base_url, comp_id), 200) # self.assertList(json, 'properties') # self.assertEquals(properties, json['properties']) # # prop = None # for p in json['properties']: # if p['id'] == Default.COMPONENT_PROPERTY: # prop = p # self.assertEquals(prop['value'], Default.COMPONENT_PROPERTY_VALUE) # # # Configure # json, resp = yield self._async_json_request( # "%s/components/%s/properties" % (self.base_url, comp_id), # 200, # 'PUT', # {'properties': [ # {'id': Default.COMPONENT_PROPERTY, 'value': Default.COMPONENT_PROPERTY_CHANGE} # ]} # ) # # json, resp = yield self._async_json_request("%s/components/%s/properties" % (self.base_url, comp_id), 200) # prop = None # for p in json['properties']: # if p['id'] == Default.COMPONENT_PROPERTY: # prop = p # self.assertEquals(prop['value'], Default.COMPONENT_PROPERTY_CHANGE) # http_client = AsyncHTTPClient() # url = self.get_url(Default.REST_BASE + self.base_url + '/components')rest-python-2.0.0/tests/defaults.py000066400000000000000000000023471245477330500173500ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # __author__ = 'rpcanno' import re class Default(object): REST_BASE = "/redhawk/rest" DOMAIN_NAME = "REDHAWK_DEV" WAVEFORM = 'SigTest' COMPONENT = 'SigGen' COMPONENT_PROPERTY = 'frequency' COMPONENT_PROPERTY_VALUE = 1000 COMPONENT_PROPERTY_CHANGE = 2000 RESOURCE_NOT_FOUND_ERR = 'ResourceNotFound' RESOURCE_NOT_FOUND_MSG_REGEX = re.compile(r"^Unable to find .[^']* '.[^']*'$") rest-python-2.0.0/tests/device.py000066400000000000000000000056011245477330500167740ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Tornado tests for the /domain/{NAME}/deviceManagers/{ID}/devices portion of the REST API """ __author__ = 'rpcanno' from base import JsonTests from defaults import Default class DeviceTests(JsonTests): def _get_dev_list(self): """ Get a list of devices from one level up (ie the control) """ json, resp = self._json_request("/domains/"+Default.DOMAIN_NAME, 200) self.assertTrue('deviceManagers' in json) self.assertTrue(isinstance(json['deviceManagers'], list)) self.assertTrue(len(json['deviceManagers']) > 0) mgr = json['deviceManagers'][0] self.assertTrue('id' in mgr) url = "/domains/"+Default.DOMAIN_NAME+"/deviceManagers/"+mgr['id'] json, resp = self._json_request(url, 200) self.assertTrue('devices' in json) self.assertTrue(isinstance(json['devices'], list)) return url, json['devices'] def test_list(self): base_url, devices = self._get_dev_list() json, resp = self._json_request(base_url+'/devices', 200) self.assertTrue('devices' in json) self.assertTrue(isinstance(json['devices'], list)) for dev in json['devices']: self.assertTrue('id' in dev) self.assertTrue('name' in dev) self.assertEquals(devices, json['devices']) def test_info(self): url, devices = self._get_dev_list() self.assertTrue(len(devices) > 0) dev = devices[0] self.assertTrue('id' in dev) json, resp = self._json_request(url+"/devices/"+dev['id'], 200) self.assertTrue('name' in json) self.assertEquals(json['name'], dev['name']) self.assertTrue('id' in json) self.assertEquals(json['id'], dev['id']) self.assertTrue('started' in json) self.assertTrue('properties' in json) self.assertTrue('ports' in json) def test_info_not_found(self): url, devices = self._get_dev_list() json, resp = self._json_request(url+"/devices/sdkafsdfhklasdfhkajl", 404) self._resource_not_found(json) rest-python-2.0.0/tests/devicemanager.py000066400000000000000000000052541245477330500203330ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Tornado tests for the /domain/{NAME}/deviceManagers portion of the REST API """ __author__ = 'rpcanno' from base import JsonTests from defaults import Default class DeviceManagerTests(JsonTests): def _get_dev_mgr_list(self): """ Get a list of device managers from one level up (ie the control) """ body, resp = self._json_request("/domains/"+Default.DOMAIN_NAME, 200) self.assertTrue('deviceManagers' in body) self.assertTrue(isinstance(body['deviceManagers'], list)) return body['deviceManagers'] def test_list(self): dev_managers = self._get_dev_mgr_list() body, resp = self._json_request("/domains/"+Default.DOMAIN_NAME+"/deviceManagers", 200) self.assertTrue('deviceManagers' in body) self.assertTrue(isinstance(body['deviceManagers'], list)) for mgr in body['deviceManagers']: self.assertTrue('id' in mgr) self.assertTrue('name' in mgr) self.assertEquals(dev_managers, body['deviceManagers']) def test_info(self): dev_managers = self._get_dev_mgr_list() self.assertTrue(len(dev_managers) > 0) mgr = dev_managers[0] self.assertTrue('id' in mgr) body, resp = self._json_request("/domains/"+Default.DOMAIN_NAME+"/deviceManagers/"+mgr['id'], 200) self.assertTrue('name' in body) self.assertEquals(body['name'], mgr['name']) self.assertTrue('id' in body) self.assertEquals(body['id'], mgr['id']) self.assertTrue('services' in body) self.assertTrue('properties' in body) self.assertTrue('devices' in body) def test_info_not_found(self): global DOMAIN_NAME body, resp = self._json_request("/domains/"+Default.DOMAIN_NAME+"/deviceManagers/sdkafsdfhklasdfhkajl", 404) self._resource_not_found(body) rest-python-2.0.0/tests/domain.py000066400000000000000000000033371245477330500170100ustar00rootroot00000000000000# # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # """ Tornado tests for the /domain portion of the REST API """ __author__ = 'rpcanno' from base import JsonTests from defaults import Default class DomainTests(JsonTests): def test_list(self): body, resp = self._json_request("/domains", 200) self.assertTrue('domains' in body) self.assertTrue(isinstance(body['domains'], list)) def test_info(self): body, resp = self._json_request("/domains/"+Default.DOMAIN_NAME, 200) self.assertTrue('name' in body) self.assertEquals(body['name'], Default.DOMAIN_NAME) self.assertTrue('applications' in body) self.assertTrue('deviceManagers' in body) self.assertTrue('properties' in body) self.assertTrue('id' in body) def test_info_not_found(self): body, resp = self._json_request("/domains/ldskfadjklfsdjkfasdl", 404) print body self._resource_not_found(body) rest-python-2.0.0/tests/port.py000077500000000000000000000064571245477330500165360ustar00rootroot00000000000000#!/usr/bin/env python # # This file is protected by Copyright. Please refer to the COPYRIGHT file # distributed with this source distribution. # # This file is part of REDHAWK rest-python. # # REDHAWK rest-python is free software: you can redistribute it and/or modify it under # the terms of the GNU Lesser General Public License as published by the Free # Software Foundation, either version 3 of the License, or (at your option) any # later version. # # REDHAWK rest-python is distributed in the hope that it will be useful, but WITHOUT # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS # FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more # details. # # You should have received a copy of the GNU Lesser General Public License # along with this program. If not, see http://www.gnu.org/licenses/. # # system imports import unittest import json import logging import time import threading from functools import partial # tornado imports import tornado import tornado.testing from tornado.testing import AsyncHTTPTestCase, LogTrapTestCase from tornado.httpclient import AsyncHTTPClient, HTTPRequest from tornado import websocket, gen from base import JsonAssertions # application imports from pyrest import Application # all method returning suite is required by tornado.testing.main() def all(): return unittest.TestLoader().loadTestsFromModule(__import__(__name__)) class PortTests(AsyncHTTPTestCase, LogTrapTestCase, JsonAssertions): # def setUp(self): # super(RESTfulTest, self).setUp() # rtl_app.RTLApp('REDHAWK_DEV').stop_survey() def get_app(self): return Application(debug=True, _ioloop=self.io_loop) @tornado.testing.gen_test def test_domain_get_instance(self): response = yield AsyncHTTPClient(self.io_loop).fetch(self.get_url('/redhawk/rest/domains/REDHAWK_DEV')) self.assertEquals(200, response.code) data = json.loads(response.body) for name in ('applications', 'properties', 'deviceManagers', 'id', 'name'): self.assertTrue(name in data, "json missing %s" % name) def test_domain_get_failure(self): # callback must be used to get response to non-200 HTTPResponse AsyncHTTPClient(self.io_loop).fetch(self.get_url('/redhawk/rest/domains/REDHAWK_DEV_FOO'), self.stop) response = self.wait() self.assertEquals(404, response.code) pdata = json.loads(response.body) logging.debug("Found port data %s", pdata) # FIXME: Check error response @tornado.testing.gen_test def test_application_port_get(self): # get a list of waveforms response = yield AsyncHTTPClient(self.io_loop).fetch(self.get_url('/redhawk/rest/domains/REDHAWK_DEV/applications')) self.assertEquals(200, response.code) data = json.loads(response.body) for wf in data['applications']: portr = yield AsyncHTTPClient(self.io_loop).fetch(self.get_url('/redhawk/rest/domains/REDHAWK_DEV/applications/%s/ports' % wf['id'])) self.assertEquals(200, portr.code) pdata = json.loads(portr.body) # FIXME: Test against a applications with ports logging.debug("Found port data %s", pdata) break else: self.fail('Unable to find any applications')