Call get/post/delete requests directly.

DailyDreaming · DailyDreaming · commit 877d16726852 · 2018-08-10T14:12:59.000-07:00
diff --git a/wes_client/util.py b/wes_client/util.py
@@ -1,7 +1,6 @@
 import os
 import json
-import urlparse
-from bravado.client import SwaggerClient
+from bravado.requests_client import RequestsClient
 import urllib
 import logging
 import schema_salad.ref_resolver
@@ -63,14 +62,6 @@ def build_wes_request(workflow_file, json_path, attachments=None):
     return parts
 
 
-def wes_client(http_client, auth, proto, host):
-    split = urlparse.urlsplit("%s://%s/" % (proto, host))
-    http_client.set_api_key(split.hostname, auth, param_name="Authorization", param_in="header")
-    client = SwaggerClient.from_url("%s://%s/ga4gh/wes/v1/swagger.json" % (proto, host),
-                                    http_client=http_client, config={"use_models": False})
-    return client.WorkflowExecutionService
-
-
 def modify_jsonyaml_paths(jsonyaml_file):
     """
     Changes relative paths in a json/yaml file to be relative
@@ -99,125 +90,116 @@ def fixpaths(d):
     visit(input_dict, fixpaths)
 
 
-def run_wf(workflow_file, jsonyaml, attachments, http_client, auth, proto, host):
-    """
-    Composes and sends a post request that signals the wes server to run a workflow.
-
-    :param str workflow_file: A local/http/https path to a cwl/wdl/python workflow file.
-    :param str jsonyaml: A local path to a json or yaml file.
-    :param list attachments: A list of local paths to files that will be uploaded to the server.
-    :param object http_client: bravado.requests_client.RequestsClient
-    :param str auth: String to send in the auth header.
-    :param proto: Schema where the server resides (http, https)
-    :param host: Port where the post request will be sent and the wes server listens at (default 8080)
-
-    :return: The body of the post result as a dictionary.
-    """
-    parts = build_wes_request(workflow_file, jsonyaml, attachments)
-    postresult = http_client.session.post("%s://%s/ga4gh/wes/v1/runs" % (proto, host),
-                                          files=parts,
-                                          headers={"Authorization": auth})
-    if postresult.status_code != 200:
-        logging.error("%s", json.loads(postresult.text))
-        exit(1)
-    return json.loads(postresult.text)
-
-
-def cancel_wf(run_id, http_client, auth, proto, host):
-    """
-    Cancel a running workflow.
-
-    :param run_id:
-    :param object http_client: bravado.requests_client.RequestsClient
-    :param str auth: String to send in the auth header.
-    :param proto: Schema where the server resides (http, https)
-    :param host: Port where the post request will be sent and the wes server listens at (default 8080)
-    :return: The body of the delete result as a dictionary.
-    """
-    postresult = http_client.session.delete("%s://%s/ga4gh/wes/v1/runs/%s" % (proto, host, run_id),
-                                            headers={"Authorization": auth})
-    if postresult.status_code != 200:
-        logging.error("%s", json.loads(postresult.text))
-        exit(1)
-    return json.loads(postresult.text)
-
-
-def get_status(run_id, http_client, auth, proto, host):
-    """
-    Get quick status info about a running workflow.
-
-    :param run_id:
-    :param object http_client: bravado.requests_client.RequestsClient
-    :param str auth: String to send in the auth header.
-    :param proto: Schema where the server resides (http, https)
-    :param host: Port where the post request will be sent and the wes server listens at (default 8080)
-    :return: The body of the get result as a dictionary.
-    """
-    postresult = http_client.session.get("%s://%s/ga4gh/wes/v1/runs/%s/status" % (proto, host, run_id),
-                                         headers={"Authorization": auth})
-    if postresult.status_code != 200:
-        logging.error("%s", json.loads(postresult.text))
-        exit(1)
-    return json.loads(postresult.text)
-
-
-def get_wf_details(run_id, http_client, auth, proto, host):
-    """
-    Get detailed info about a running workflow.
-
-    :param run_id:
-    :param object http_client: bravado.requests_client.RequestsClient
-    :param str auth: String to send in the auth header.
-    :param proto: Schema where the server resides (http, https)
-    :param host: Port where the post request will be sent and the wes server listens at (default 8080)
-    :return: The body of the get result as a dictionary.
-    """
-    postresult = http_client.session.get("%s://%s/ga4gh/wes/v1/runs/%s" % (proto, host, run_id),
-                                         headers={"Authorization": auth})
-    if postresult.status_code != 200:
-        logging.error("%s", json.loads(postresult.text))
-        exit(1)
-    return json.loads(postresult.text)
-
-
-def get_wf_list(http_client, auth, proto, host):
-    """
-    List the workflows, this endpoint will list the workflows
-    in order of oldest to newest. There is no guarantee of
-    live updates as the user traverses the pages, the behavior
-    should be decided (and documented) by each implementation.
-
-    :param object http_client: bravado.requests_client.RequestsClient
-    :param str auth: String to send in the auth header.
-    :param proto: Schema where the server resides (http, https)
-    :param host: Port where the post request will be sent and the wes server listens at (default 8080)
-    :return: The body of the get result as a dictionary.
-    """
-    postresult = http_client.session.get("%s://%s/ga4gh/wes/v1/runs" % (proto, host),
-                                         headers={"Authorization": auth})
+def wes_reponse(postresult):
     if postresult.status_code != 200:
         logging.error("%s", json.loads(postresult.text))
         exit(1)
     return json.loads(postresult.text)
 
 
-def get_service_info(http_client, auth, proto, host):
-    """
-    Get information about Workflow Execution Service. May
-    include information related (but not limited to) the
-    workflow descriptor formats, versions supported, the
-    WES API versions supported, and information about general
-    the service availability.
-
-    :param object http_client: bravado.requests_client.RequestsClient
-    :param str auth: String to send in the auth header.
-    :param proto: Schema where the server resides (http, https)
-    :param host: Port where the post request will be sent and the wes server listens at (default 8080)
-    :return: The body of the get result as a dictionary.
-    """
-    postresult = http_client.session.get("%s://%s/ga4gh/wes/v1/service-info" % (proto, host),
-                                         headers={"Authorization": auth})
-    if postresult.status_code != 200:
-        logging.error("%s", json.loads(postresult.text))
-        exit(1)
-    return json.loads(postresult.text)
+class WESClient(object):
+    def __init__(self, service):
+        self.auth = service['auth']
+        self.proto = service['proto']
+        self.host = service['host']
+        self.http_client = RequestsClient()
+
+    def get_service_info(self):
+        """
+        Get information about Workflow Execution Service. May
+        include information related (but not limited to) the
+        workflow descriptor formats, versions supported, the
+        WES API versions supported, and information about general
+        the service availability.
+
+        :param object http_client: bravado.requests_client.RequestsClient
+        :param str auth: String to send in the auth header.
+        :param proto: Schema where the server resides (http, https)
+        :param host: Port where the post request will be sent and the wes server listens at (default 8080)
+        :return: The body of the get result as a dictionary.
+        """
+        postresult = self.http_client.session.get("%s://%s/ga4gh/wes/v1/service-info" % (self.proto, self.host),
+                                                  headers={"Authorization": self.auth})
+        return wes_reponse(postresult)
+
+    def list_runs(self):
+        """
+        List the workflows, this endpoint will list the workflows
+        in order of oldest to newest. There is no guarantee of
+        live updates as the user traverses the pages, the behavior
+        should be decided (and documented) by each implementation.
+
+        :param object http_client: bravado.requests_client.RequestsClient
+        :param str auth: String to send in the auth header.
+        :param proto: Schema where the server resides (http, https)
+        :param host: Port where the post request will be sent and the wes server listens at (default 8080)
+        :return: The body of the get result as a dictionary.
+        """
+        postresult = self.http_client.session.get("%s://%s/ga4gh/wes/v1/runs" % (self.proto, self.host),
+                                                  headers={"Authorization": self.auth})
+        return wes_reponse(postresult)
+
+    def run(self, wf, jsonyaml, attachments):
+        """
+        Composes and sends a post request that signals the wes server to run a workflow.
+
+        :param str workflow_file: A local/http/https path to a cwl/wdl/python workflow file.
+        :param str jsonyaml: A local path to a json or yaml file.
+        :param list attachments: A list of local paths to files that will be uploaded to the server.
+        :param object http_client: bravado.requests_client.RequestsClient
+        :param str auth: String to send in the auth header.
+        :param proto: Schema where the server resides (http, https)
+        :param host: Port where the post request will be sent and the wes server listens at (default 8080)
+
+        :return: The body of the post result as a dictionary.
+        """
+        parts = build_wes_request(wf, jsonyaml, attachments)
+        postresult = self.http_client.session.post("%s://%s/ga4gh/wes/v1/runs" % (self.proto, self.host),
+                                                   files=parts,
+                                                   headers={"Authorization": self.auth})
+        return wes_reponse(postresult)
+
+    def cancel(self, run_id):
+        """
+        Cancel a running workflow.
+
+        :param run_id:
+        :param object http_client: bravado.requests_client.RequestsClient
+        :param str auth: String to send in the auth header.
+        :param proto: Schema where the server resides (http, https)
+        :param host: Port where the post request will be sent and the wes server listens at (default 8080)
+        :return: The body of the delete result as a dictionary.
+        """
+        postresult = self.http_client.session.delete("%s://%s/ga4gh/wes/v1/runs/%s" % (self.proto, self.host, run_id),
+                                                     headers={"Authorization": self.auth})
+        return wes_reponse(postresult)
+
+    def get_run_log(self, run_id):
+        """
+        Get detailed info about a running workflow.
+
+        :param run_id:
+        :param object http_client: bravado.requests_client.RequestsClient
+        :param str auth: String to send in the auth header.
+        :param proto: Schema where the server resides (http, https)
+        :param host: Port where the post request will be sent and the wes server listens at (default 8080)
+        :return: The body of the get result as a dictionary.
+        """
+        postresult = self.http_client.session.get("%s://%s/ga4gh/wes/v1/runs/%s" % (self.proto, self.host, run_id),
+                                                  headers={"Authorization": self.auth})
+        return wes_reponse(postresult)
+
+    def get_run_status(self, run_id):
+        """
+        Get quick status info about a running workflow.
+
+        :param run_id:
+        :param object http_client: bravado.requests_client.RequestsClient
+        :param str auth: String to send in the auth header.
+        :param proto: Schema where the server resides (http, https)
+        :param host: Port where the post request will be sent and the wes server listens at (default 8080)
+        :return: The body of the get result as a dictionary.
+        """
+        postresult = self.http_client.session.get("%s://%s/ga4gh/wes/v1/runs/%s/status" % (self.proto, self.host, run_id),
+                                             headers={"Authorization": self.auth})
+        return wes_reponse(postresult)
diff --git a/wes_client/wes_client_main.py b/wes_client/wes_client_main.py
@@ -8,10 +8,7 @@
 import logging
 import requests
 from requests.exceptions import InvalidSchema, MissingSchema
-from wes_client.util import (run_wf,
-                             wes_client,
-                             modify_jsonyaml_paths)
-from bravado.requests_client import RequestsClient
+from wes_client.util import modify_jsonyaml_paths, WESClient
 
 
 def main(argv=sys.argv[1:]):
@@ -52,26 +49,25 @@ def main(argv=sys.argv[1:]):
         print(u"%s %s" % (sys.argv[0], pkg[0].version))
         exit(0)
 
-    http_client = RequestsClient()
-    client = wes_client(http_client, args.auth, args.proto, args.host)
+    client = WESClient({'auth': args.auth, 'proto': args.proto, 'host': args.host})
 
     if args.list:
-        response = client.ListRuns(page_token=args.page, page_size=args.page_size)
+        response = client.list_runs()  # how to include: page_token=args.page, page_size=args.page_size ?
         json.dump(response.result(), sys.stdout, indent=4)
         return 0
 
     if args.log:
-        response = client.GetRunLog(run_id=args.log)
+        response = client.get_run_log(run_id=args.log)
         sys.stdout.write(response.result()["workflow_log"]["stderr"])
         return 0
 
     if args.get:
-        response = client.GetRunLog(run_id=args.get)
+        response = client.get_run_log(run_id=args.get)
         json.dump(response.result(), sys.stdout, indent=4)
         return 0
 
     if args.info:
-        response = client.GetServiceInfo()
+        response = client.get_service_info()
         json.dump(response.result(), sys.stdout, indent=4)
         return 0
 
@@ -91,28 +87,22 @@ def main(argv=sys.argv[1:]):
         logging.basicConfig(level=logging.INFO)
 
     args.attachments = args.attachments if not args.attachments else args.attachments.split(',')
-    r = run_wf(args.workflow_url,
-               args.job_order,
-               args.attachments,
-               http_client,
-               args.auth,
-               args.proto,
-               args.host)
+    r = client.run(args.workflow_url, args.job_order, args.attachments)
 
     if args.wait:
         logging.info("Workflow run id is %s", r["run_id"])
     else:
         sys.stdout.write(r["run_id"] + "\n")
         exit(0)
 
-    r = client.GetRunStatus(run_id=r["run_id"]).result()
+    r = client.get_run_status(run_id=r["run_id"]).result()
     while r["state"] in ("QUEUED", "INITIALIZING", "RUNNING"):
         time.sleep(8)
-        r = client.GetRunStatus(run_id=r["run_id"]).result()
+        r = client.get_run_status(run_id=r["run_id"]).result()
 
     logging.info("State is %s", r["state"])
 
-    s = client.GetRunLog(run_id=r["run_id"]).result()
+    s = client.get_run_log(run_id=r["run_id"]).result()
 
     try:
         # TODO: Only works with Arvados atm
