Merge pull request #89 from amal-thundiyil/build

Fixed build errors and added Docker

Author: Mec-iS

.github/PULL_REQUEST_TEMPLATE.md

@@ -4,10 +4,12 @@
 Fixes #
 
 ### Checklist
+
 - [ ] My branch is up-to-date with upstream/develop branch.
-- [ ] Everything works and tested for Python 3.5.2 and above.
+- [ ] Everything works and tested for Python 3.8 and above.
 
 ### Description
+
 <!-- Describe about what this PR does, previous state and new state of the output -->
 
 ### Change logs
@@ -17,18 +19,15 @@ Fixes #
 <!-- - Feature 1 -->
 <!-- - Feature 2 -->
 
-
 <!-- #### Changed -->
 <!-- Edit these points below to describe the changes made in existing functionality with this PR -->
 <!-- - Change 1 -->
 <!-- - Change 1 -->
 
-
 <!-- #### Fixed -->
 <!-- Edit these points below to describe the bug fixes made with this PR -->
 <!-- - Bug 1 -->
 
-
 <!-- #### Removed -->
 <!-- Edit these points below to describe the removed features with this PR -->
 <!-- - Deprecated feature 1 -->

.travis.yml

@@ -1,8 +1,26 @@
-language: node_js
-node_js:
-  - "node"
-
-script:
-  - cd console-frontend 
-  - npm install 
-  - npm run lint
+jobs:
+  include:
+    - language: node_js
+      node: "node"
+
+      script:
+        - cd console-frontend
+        - npm install
+        - npm run lint
+
+    - language: python
+      python:
+        - "3.8"
+        - "3.8-dev" # 3.8 development branch
+
+      services:
+        - docker
+
+      before_script:
+        - docker run -d -p 6379:6379 -it --rm --name redisgraph redislabs/redisgraph:2.0-edge
+
+      install:
+        - pip install -r requirements.txt --no-cache
+
+      script:
+        - echo "skipping tests"

Dockerfile

@@ -0,0 +1,14 @@
+FROM python:3
+
+WORKDIR /app
+
+COPY ./requirements.txt requirements.txt
+
+RUN pip install -U pip && pip install --upgrade pip setuptools \
+    && pip install -r requirements.txt 
+
+COPY  . /app
+
+ENV PYTHONPATH "${PYTHONPATH}:/app"
+
+ENV MESSAGE "Hail Hydra"

app.py

@@ -2,12 +2,10 @@
 from flask_cors import CORS
 from hydra_agent.agent import Agent
 import sys
-import json, os
-from requests import get
+import json
+import os
 
-from lib.utils import serve, start_agent, hydra_doc, apidoc_graph, send_command, default
-
-app = Flask(__name__, static_folder='console-frontend/build/')
+app = Flask(__name__, static_folder="console-frontend/build/")
 
 # Setting CORS so it allows requests from our React app in localhost:3000
 CORS(app, resources={r"*": {"origins": "http://localhost:3000"}})
@@ -16,13 +14,208 @@
 url = "http://localhost:8080/serverapi"
 agent = Agent(url)
 
-app.add_url_rule('/<path:path>', 'serve', serve)
-app.add_url_rule('/start-agent', 'start-agent', start_agent)
-app.add_url_rule('/hydra-doc', 'hydra-doc', hydra_doc)
-app.add_url_rule('/apidoc-graph', 'apidoc-graph', apidoc_graph)
-app.add_url_rule('/send-command', 'send-command', send_command)
-app.add_url_rule('/','default', default)
+
+@app.route("/", defaults={"path": ""})
+@app.route("/<path:path>")
+def serve(path):
+    """Default endpoint, it serves the built static React App
+    :return: Served file
+    """
+    file_path = os.path.join(app.static_folder, path)
+    if path != "" and os.path.exists(file_path):
+        return send_from_directory(app.static_folder, path)
+    else:
+        return send_from_directory(app.static_folder, "index.html")
+
+
+@app.route("/start-agent", methods=["POST"])
+def start_agent():
+    """Receive hydrus server URL and start the Agent
+    :param body['url']: Entrypoint URL for the hydrus server
+    :return: Success message
+    """
+    global agent
+    global url
+    body = request.get_data()
+    body = body.decode("utf8").replace("'", '"')
+    body = json.loads(body)
+    url = body["url"]
+    agent = Agent(url)
+    return "Server started successfully"
+
+
+@app.route("/hydra-doc", methods=["GET"])
+def hydra_doc():
+    """Serve Hydra Doc
+    :return: Hydra Doc loaded on the agent with url for current connected
+    """
+    apidoc = agent.fetch_apidoc()
+    generatedApiDoc = apidoc.generate()
+    generatedApiDoc["serverURL"] = url
+    return generatedApiDoc
+
+
+@app.route("/apidoc-graph", methods=["GET"])
+def apidoc_graph():
+    """Sends Formatted ApiDoc Graph in Vis.js network format to Frontend
+    :return: Dict containing Nodes and Edges
+    """
+    global agent
+    if agent is None:
+        return "No agent connected."
+    # Add the entrypoint node
+    nodes = [{"id": 1, "shape": "hexagon", "size": 15, "label": "Entrypoint"}]
+    edges = list()
+    id = 1
+    api_doc = agent.fetch_apidoc()
+    for resource_endpoint in api_doc.entrypoint.entrypoint.supportedProperty:
+        id += 1
+        endpoint_id = id
+        endpoint_path = resource_endpoint.id_.replace("vocab:EntryPoint/", "")
+        endpoint_node = create_node(endpoint_id, "box", 12, endpoint_path)
+        nodes.append(endpoint_node)
+        edge = create_edge(1, endpoint_id)
+        edges.append(edge)
+        for supportedOp in resource_endpoint.supportedOperation:
+            id += 1
+            op_id = id
+            operation_node = create_node(op_id, "circle", 10, supportedOp.method)
+            nodes.append(operation_node)
+            supportedOp_edge = create_edge(endpoint_id, op_id, "supportedOp")
+            edges.append(supportedOp_edge)
+            if supportedOp.expects:
+                expects = supportedOp.expects
+            else:
+                expects = "null"
+            if supportedOp.returns:
+                returns = supportedOp.returns
+            else:
+                returns = "null"
+            # Extract class name
+            if "vocab:" in expects:
+                expects = expects.replace("vocab:", "")
+            if "vocab:" in returns:
+                returns = returns.replace("vocab:", "")
+            id += 1
+            expected_class_node = create_node(id, "circle", 8, expects)
+            nodes.append(expected_class_node)
+            expects_edge = create_edge(op_id, id, "expects")
+            edges.append(expects_edge)
+            if expects in api_doc.parsed_classes:
+                class_id = id
+                for supportedProp in api_doc.parsed_classes[expects][
+                    "class"
+                ].supportedProperty:
+                    id += 1
+                    property_node = create_node(id, "box", 7, supportedProp.title)
+                    nodes.append(property_node)
+                    property_edge = create_edge(class_id, id, "supportedProp")
+                    edges.append(property_edge)
+            id += 1
+            returned_class_node = create_node(id, "circle", 8, returns)
+            nodes.append(returned_class_node)
+            returns_edge = create_edge(op_id, id, "returns")
+            edges.append(returns_edge)
+            if returns in api_doc.parsed_classes:
+                class_id = id
+                for supportedProp in api_doc.parsed_classes[returns][
+                    "class"
+                ].supportedProperty:
+                    id += 1
+                    property_node = create_node(id, "box", 7, supportedProp.title)
+                    nodes.append(property_node)
+                    property_edge = create_edge(class_id, id, "supportedProp")
+                    edges.append(property_edge)
+    graph = {"nodes": nodes, "edges": edges}
+    return graph
+
+
+def create_node(id, shape, size, label):
+    """Auxiliary function that creates a Node in Vis.js format
+    :return: Dict with Node attributes
+    """
+    node = {
+        "id": id,
+        "shape": shape,
+        "size": size,
+        "label": label,
+        "color": {"background": "#FBD20B"},
+    }
+    return node
+
+
+def create_edge(from_, to, label=None):
+    """Auxiliary function that creates a Edge in Vis.js format
+    :return: Dict with Edge attributes
+    """
+    edge = {"from": from_, "to": to}
+    if label is not None:
+        edge["label"] = label
+    return edge
+
+
+@app.route("/send-command", methods=["POST"])
+def send_command():
+    """Send Command to Agent and returns hydrus response
+    :param: All parameters enabled by the Agent.
+    :param: Please check Agent.py in Agent's main repository.
+    :return: hydrus response to the request
+    """
+    global agent
+    if agent is None:
+        return "No agent connected."
+    body = request.get_data()
+    body = body.decode("utf8")
+    body = json.loads(body)
+    if "method" not in body:
+        return "Request must have a method."
+    if body["method"] == "get":
+        # Get optional parameters
+        filters = body.get("filters", {})
+        cached_limit = body.get("cached_limit", sys.maxsize)
+        if "url" in body:
+            return json.dumps(
+                agent.get(url=body["url"], filters=filters, cached_limit=cached_limit)
+            )
+        elif "resource_type" in body:
+            return json.dumps(
+                agent.get(
+                    resource_type=body["resource_type"],
+                    filters=filters,
+                    cached_limit=cached_limit,
+                )
+            )
+        else:
+            return "Must contain url or the resource type"
+    elif body["method"] == "put":
+        if "url" in body:
+            url = body["url"]
+        else:
+            return "Put request must contain a url"
+        if "new_object" in body:
+            new_object = body["new_object"]
+        else:
+            return "Put request must contain the new_object."
+        return json.dumps(agent.put(url, new_object))
+    elif body["method"] == "post":
+        if "url" in body:
+            url = body["url"]
+        else:
+            return "Post request must contain a url"
+        if "updated_object" in body:
+            updated_object = body["updated_object"]
+        else:
+            return "Put request must contain the updated_object."
+        return json.dumps(agent.post(url, updated_object))
+    elif body["method"] == "delete":
+        if "url" in body:
+            url = body["url"]
+        else:
+            return "Delete request must contain a url"
+        return json.dumps(agent.delete(url))
+    else:
+        return "Method not supported."
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     app.run(use_reloader=True, port=3000, threaded=True)