Client WebApp API

dataikuapi/dss/project.py

@@ -15,6 +15,7 @@
 from .discussion import DSSObjectDiscussions
 from .ml import DSSMLTask
 from .analysis import DSSAnalysis
+from .webapp import DSSWebApp
 from dataikuapi.utils import DataikuException
 
 
@@ -823,6 +824,28 @@ def get_macro(self, runnable_type):
         """
         return DSSMacro(self.client, self.project_key, runnable_type)
 
+    ########################################################
+    # Webapps
+    ########################################################
+
+    def list_webapps(self):
+        """
+        List the webapps heads of this project
+
+        :returns: the list of the webapps as :class:`dataikuapi.dss.webapp.DSSWebApp`
+        """
+        webapps = self.client._perform_json("GET", "/projects/%s/webapps/" % self.project_key)
+        return [DSSWebApp(self.client, self.project_key, w["id"]) for w in webapps]
+
+    def get_webapp(self, webapp_id):
+        """
+        Get a handle to interact with a specific webapp
+
+        :param webapp_id: the identifier of a webapp
+        :returns: A :class:`dataikuapi.dss.webapp.DSSWebApp` webapp handle
+        """
+        return DSSWebApp(self.client, self.project_key, webapp_id)
+
     ########################################################
     # Wiki
     ########################################################

dataikuapi/dss/webapp.py

@@ -0,0 +1,121 @@
+import sys
+from .future import DSSFuture
+
+if sys.version_info >= (3,0):
+  import urllib.parse
+  dku_quote_fn = urllib.parse.quote
+else:
+  import urllib
+  dku_quote_fn = urllib.quote
+
+
+class DSSWebApp(object):
+    """
+    A handle to manage a webapp
+    """
+    def __init__(self, client, project_key, webapp_id):
+        """Do not call directly, use :meth:`dataikuapi.dss.project.DSSProject.get_webapps`"""
+        self.client = client
+        self.project_key = project_key
+        self.webapp_id = webapp_id
+
+    def get_state(self):
+        """
+        Return the state of the webapp
+
+        :return: the state of the webapp
+        :rtype: :class:`DSSWebAppBackendState`
+        """
+        state = self.client._perform_json("GET", "/projects/%s/webapps/%s/backend/state" % (self.project_key, self.webapp_id))
+        return DSSWebAppBackendState(self.client, self.project_key, self.webapp_id, state)
+
+    def stop_backend(self):
+        """
+        Stop a webapp
+        """
+        self.client._perform_empty("PUT", "/projects/%s/webapps/%s/backend/actions/stop" % (self.project_key, self.webapp_id))
+
+    def restart_backend(self):
+        """
+        Restart a webapp
+        :returns: a handle to a DSS future to track the progress of the restart
+        :rtype: :class:`dataikuapi.dss.future.DSSFuture`
+        """
+        future = self.client._perform_json("PUT", "/projects/%s/webapps/%s/backend/actions/restart" % (self.project_key, self.webapp_id))
+        return DSSFuture(self.client, future["jobId"])
+
+    def get_definition(self):
+        """
+        Get a webapp definition
+
+        :returns: a handle to manage the webapp definition
+        :rtype: :class:`dataikuapi.dss.webapp.DSSWebAppDefinition`
+        """
+        definition = self.client._perform_json("GET", "/projects/%s/webapps/%s/" % (self.project_key, self.webapp_id))
+        return DSSWebAppDefinition(self.client, self.project_key, self.webapp_id, definition)
+
+
+class DSSWebAppBackendState(object):
+    """
+    A handle to manage WebApp backend state
+    """
+    def __init__(self, client, project_key, webapp_id, state):
+        """Do not call directly, use :meth:`dataikuapi.dss.webapp.DSSWebApp.get_state`"""
+        self.client = client
+        self.project_key = project_key
+        self.webapp_id = webapp_id
+        self.state = state
+
+    def get_state(self):
+        """
+        Returns the dict containing the current state of the webapp backend.
+        Warning : this dict is replaced when webapp backend state changes
+
+        :returns: a dict
+        """
+        return self.state
+
+    def is_running(self):
+        """
+        Tells if the webapp app backend is running or not
+
+        :returns: a bool
+        """
+        return "futureInfo" in self.state and \
+               "alive" in self.state["futureInfo"] and \
+               self.state["futureInfo"]["alive"]
+
+
+class DSSWebAppDefinition(object):
+    """
+    A handle to manage a WebApp definition
+    """
+    def __init__(self, client, project_key, webapp_id, definition):
+        """Do not call directly, use :meth:`dataikuapi.dss.webapp.DSSWebApp.get_definition`"""
+        self.client = client
+        self.project_key = project_key
+        self.webapp_id = webapp_id
+        self.definition = definition
+
+    def get_definition(self):
+        """
+        Get the definition
+
+        :returns: the definition of the webapp
+        """
+        return self.definition
+
+    def set_definition(self, definition):
+        """
+        Set the definition
+
+        :param definition : the definition of the webapp
+        """
+        self.definition = definition
+
+    def save(self):
+        """
+        Save the current webapp definition and update it.
+        """
+        self.client._perform_json("PUT", "/projects/%s/webapps/%s" % (self.project_key, self.webapp_id), body=self.definition)
+        self.definition = self.client._perform_json("GET", "/projects/%s/webapps/%s" % (self.project_key, self.webapp_id))

tests/user_tests.py

@@ -13,23 +13,23 @@ def list_users_test():
 
 def create_delete_user_test():
 	client = DSSClient(host, apiKey)
-	count = len(client.list_users())	
-	
+	count = len(client.list_users())
+
 	user = client.create_user("toto", "password", "display name of toto", groups=['a','b'])
 	eq_(count + 1, len(client.list_users()))
-	
+
 	user.delete()
 	eq_(count, len(client.list_users()))
-	
+
 def get_set_user_test():
 	client = DSSClient(host, apiKey)
 	user = client.create_user("toto", "password", "display name of toto", groups=['a','b'])
-	
+
 	desc = user.get_definition()
 	desc['displayName'] = 'tata'
 	user.set_definition(desc)
 	desc2 = user.get_definition()
-	
+
 	eq_('tata', desc2['displayName'])
 
 	user.delete()

tests/webapps_tests.py

@@ -0,0 +1,82 @@
+from time import sleep
+from dataikuapi.dssclient import DSSClient
+from dataikuapi.dss.project import DSSProject
+from dataikuapi.dss.webapp import DSSWebApp
+from nose.tools import ok_
+from nose.tools import eq_
+
+host="http://localhost:8083"
+apiKey="CMZBjFkUgcDh08S3awoPyVIweBelxPjy"
+testProjectKey="WEBAPPS"
+testWebAppPythonId="VCMN2ra"
+
+
+def remove_key(d, key):
+	r = dict(d)
+	del r[key]
+	return r
+
+
+class WebappApi_tests(object):
+
+	def __init__(self):
+		self.client = None
+		self.project = None;
+
+	def setUp(self):
+		self.client = DSSClient(host, apiKey)
+		self.project = DSSProject(self.client, testProjectKey)
+
+	def t01_list_webapps_test(self):
+		webapps = self.project.list_webapps();
+		ok_(len(webapps) > 0)
+
+	def t02_get_python_webapp_test(self):
+		webapp = self.project.get_webapp(testWebAppPythonId)
+		ok_(webapp is not None)
+
+	def t03_get_definition_test(self):
+		webapp = self.project.get_webapp(testWebAppPythonId)
+		definition = webapp.get_definition()
+		print "Definition " + str(definition)
+		ok_(definition is not None)
+		eq_(definition.webapp_id, testWebAppPythonId)
+		eq_(definition.get_definition()["id"], testWebAppPythonId)
+
+	def t04_update_python_webapp_test(self):
+		webapp = self.project.get_webapp(testWebAppPythonId)
+		definition = webapp.get_definition()
+		old_def = dict(definition.get_definition())
+		definition.save()
+		eq_(remove_key(definition.get_definition(), "versionTag"), remove_key(old_def, "versionTag"))
+		eq_(definition.get_definition()["versionTag"]["versionNumber"], old_def["versionTag"]["versionNumber"] + 1)
+
+	def t05_restart_backend_test(self):
+		"""
+		WARNING: you should manually stop the backend before this test
+		"""
+		webapp = self.project.get_webapp(testWebAppPythonId)
+		ok_(not webapp.get_state().is_running(), "The backend should be stopped before the test")
+		future = webapp.restart_backend()
+		future.wait_for_result()
+		ok_(webapp.get_state().is_running())
+
+	def t06_stop_backend_test(self):
+		"""
+		WARNING: you should manually start the backend before this test
+		"""
+		webapp = self.project.get_webapp(testWebAppPythonId)
+		ok_(webapp.get_state().is_running(),"The backend should be started before the test")
+		webapp.stop_backend()
+		sleep(2)
+		eq_(webapp.get_state().is_running(), False)
+
+	def t07_state_consistency_test(self):
+		webapp = self.project.get_webapp(testWebAppPythonId)
+		webapp.stop_backend()
+		eq_(webapp.get_state().is_running(), False)
+		future = webapp.restart_backend()
+		future.wait_for_result()
+		eq_(webapp.get_state().is_running(), True)
+		webapp.stop_backend()
+		eq_(webapp.get_state().is_running(), False)