Integration of the WS REST APi.

# World Analysis HHI Wrapper

*This repository is part of the outcomes of the Specialist Task Force 669 focusing on the communication between a World Analysis and World Representation components as part of the ETSI ISG Augmented Reality Framework architecture (https://www.etsi.org/deliver/etsi_gs/ARF/001_099/003/01.01.01_60/gs_ARF003v010101p.pdf).*

*The set of the World Representation authoring components includes:*

*•	The Python, C++ and C# source code for servers and clients generated from OpenAPI available here (https://forge.etsi.org/rep/arf/arf005)*

*•	A Unity plugin and a Unity editor for authoring and accessing a World Representation hosted on a World Storage server.*

## Getting started

*All these components are available under the ETSI Labs group “World Storage API Helpers”: https://labs.etsi.org/rep/arf/world-storage-api-helpers*

To make it easy for you to get started with GitLab, here's a list of recommended next steps.

*If you wish to contribute to this project or any other projects in the context of the [ETSI ISG Augmented Reality Framework architecture](https://www.etsi.org/committee/1420-arf), please refer to the ["How to get involved in an ISG" section on the ETSI website](https://www.etsi.org/how-to-get-involved-in-an-isg)*

Already a pro? Just edit this README.md and make it your own. Want to make it easy? [Use the template at the bottom](#editing-this-readme)!

---

## Add your files

# Description

- [ ] [Create](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#create-a-file) or [upload](https://docs.gitlab.com/ee/user/project/repository/web_editor.html#upload-a-file) files

- [ ] [Add files using the command line](https://docs.gitlab.com/ee/gitlab-basics/add-file.html#add-a-file-using-the-command-line) or push an existing Git repository with the following command:

This repo should be used to construct a Python server compliant to the ARF World Storage API. It uses auto-generated python server code. We propose to use the open source OpenAPI-Generator for this.

```

cd existing_repo

git remote add origin https://labs.etsi.org/rep/arf/world-analysis-api-helpers/world-analysis-hhi-wrapper.git

git branch -M main

git push -uf origin main

```

## Integrate with your tools

- [ ] [Set up project integrations](https://labs.etsi.org/rep/arf/world-analysis-api-helpers/world-analysis-hhi-wrapper/-/settings/integrations)

## Collaborate with your team

- [ ] [Invite team members and collaborators](https://docs.gitlab.com/ee/user/project/members/)

- [ ] [Create a new merge request](https://docs.gitlab.com/ee/user/project/merge_requests/creating_merge_requests.html)

- [ ] [Automatically close issues from merge requests](https://docs.gitlab.com/ee/user/project/issues/managing_issues.html#closing-issues-automatically)

- [ ] [Enable merge request approvals](https://docs.gitlab.com/ee/user/project/merge_requests/approvals/)

- [ ] [Automatically merge when pipeline succeeds](https://docs.gitlab.com/ee/user/project/merge_requests/merge_when_pipeline_succeeds.html)

## Test and Deploy

Use the built-in continuous integration in GitLab.

- [ ] [Get started with GitLab CI/CD](https://docs.gitlab.com/ee/ci/quick_start/index.html)

- [ ] [Analyze your code for known vulnerabilities with Static Application Security Testing(SAST)](https://docs.gitlab.com/ee/user/application_security/sast/)

- [ ] [Deploy to Kubernetes, Amazon EC2, or Amazon ECS using Auto Deploy](https://docs.gitlab.com/ee/topics/autodevops/requirements.html)

- [ ] [Use pull-based deployments for improved Kubernetes management](https://docs.gitlab.com/ee/user/clusters/agent/)

- [ ] [Set up protected environments](https://docs.gitlab.com/ee/ci/environments/protected_environments.html)

***

# Editing this README

## Repo Content

When you're ready to make this README your own, just edit this file and use the handy template below (or feel free to structure it however you want - this is just a starting point!). Thank you to [makeareadme.com](https://www.makeareadme.com/) for this template.

|   |  Files / Folders |                                                                                    Description                                                                                    |

|:-:|:--------------:|:---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------:|

| 📂 | wrapper  | The folder where the python World Analysis code with WS REST and WA websocket connection is implemented |

## Suggestions for a good README

Every project is different, so consider which of these sections apply to yours. The sections used in the template are suggestions for most open source projects. Also keep in mind that while a README can be too long and detailed, too long is better than too short. If you think your README is too long, consider utilizing another form of documentation rather than cutting out information.

## Requirements

## Name

Choose a self-explaining name for your project.

What you need:

## Description

Let people know what your project can do specifically. Provide context and add a link to any reference visitors might be unfamiliar with. A list of Features or a Background subsection can also be added here. If there are alternatives to your project, this is a good place to list differentiating factors.

1.	Installed npm: https://phoenixnap.com/kb/install-node-js-npm-on-windows

2.	Installed openapi generator with npm: https://openapi-generator.tech/docs/installation/

3.	Optional: Installed docker (recommanded): https://www.docker.com/get-started 

## Badges

On some READMEs, you may see small images that convey metadata, such as whether or not all the tests are passing for the project. You can use Shields to add some to your README. Many services also have instructions for adding a badge.

## Visuals

Depending on what you are making, it can be a good idea to include screenshots or even a video (you'll frequently see GIFs rather than actual videos). Tools like ttygif can help, but check out Asciinema for a more sophisticated method.

## Installing the python module on your local computer

## Installation

Within a particular ecosystem, there may be a common way of installing things, such as using Yarn, NuGet, or Homebrew. However, consider the possibility that whoever is reading your README is a novice and would like more guidance. Listing specific steps helps remove ambiguity and gets people to using your project as quickly as possible. If it only runs in a specific context like a particular programming language version or operating system or has dependencies that have to be installed manually, also add a Requirements subsection.

It's recommended to create the enviroment with conda (if available)

## Usage

Use examples liberally, and show the expected output if you can. It's helpful to have inline the smallest example of usage that you can demonstrate, while providing links to more sophisticated examples if they are too long to reasonably include in the README.

## Support

Tell people where they can go to for help. It can be any combination of an issue tracker, a chat room, an email address, etc.

## Roadmap

If you have ideas for releases in the future, it is a good idea to list them in the README.

```

conda create -n openapi

conda activate openapi

```

## Contributing

State if you are open to contributions and what your requirements are for accepting them.

Install the common apckae for async WebSockets:

For people who want to make changes to your project, it's helpful to have some documentation on how to get started. Perhaps there is a script that they should run or some environment variables that they need to set. Make these steps explicit. These instructions could also be useful to your future self.

```

pip install websockets

```

You can also document commands to lint the code or run tests. These steps help to ensure high code quality and reduce the likelihood that the changes inadvertently break something. Having instructions for running tests is especially helpful if it requires external setup, such as starting a Selenium server for testing in a browser.

In case of not having the pip installed for your cml you can use following line:

## Authors and acknowledgment

Show your appreciation to those who have contributed to the project.

```

py -m pip install websockets

```

## License

For open source projects, say how it is licensed.

## Running the test script

## Project status

If you have run out of energy or time for your project, put a note at the top of the README saying that development has slowed down or stopped completely. Someone may choose to fork your project or volunteer to step in as a maintainer or owner, allowing your project to keep going. You can also make an explicit request for maintainers.

Run python script with:

```

cd wrapper

python WorldAnalysisWrapper.py

```

 No newline at end of file

#!/usr/bin/env python

#

# ARF - Augmented Reality Framework (ETSI ISG ARF)

#

# Copyright 2024 ETSI

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#     http:#www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

#

# Last change: July 2024

#

import time

import asyncio

import pathlib

import websockets;

import ssl

from pprint import pprint

from websockets.server import serve

print()

print("ETSI ISG - Test WebSocket Server")

print()

print()

success = 0

# certificate

localhost_pem = pathlib.Path(__file__).with_name("localhost.pem")

print(f"Using PEM: {localhost_pem}")

print()

# See here: https://websockets.readthedocs.io/en/stable/howto/quickstart.html#encrypt-connections

my_ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)

my_ssl_context.load_verify_locations(localhost_pem)

# https://websockets.readthedocs.io/en/stable/index.html

async def echo(websocket):

    async for message in websocket:

        print(f"Got: { message }")

        await websocket.send(message)

async def main():

    async with serve(echo, "localhost", 8765):

        await asyncio.Future()  # run forever

asyncio.run(main())

 No newline at end of file

#!/usr/bin/env python

#

# ARF - Augmented Reality Framework (ETSI ISG ARF)

#

# Copyright 2024 ETSI

#

# Licensed under the Apache License, Version 2.0 (the "License");

# you may not use this file except in compliance with the License.

# You may obtain a copy of the License at

#

#     http:#www.apache.org/licenses/LICENSE-2.0

#

# Unless required by applicable law or agreed to in writing, software

# distributed under the License is distributed on an "AS IS" BASIS,

# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

# See the License for the specific language governing permissions and

# limitations under the License.

#

# Last change: August 2024

#

import time

import pathlib

import ssl

import asyncio

from pprint import pprint

import websockets;

#from websockets.sync.client import connect

#import websocket;  // test

import ETSI.ARF.OpenAPI.WorldStorage

from ETSI.ARF.OpenAPI.WorldStorage.api import default_api

from ETSI.ARF.OpenAPI.WorldStorage.api import trackables_api

from ETSI.ARF.OpenAPI.WorldStorage.api import world_anchors_api

from ETSI.ARF.OpenAPI.WorldStorage.api import world_links_api

# recommended to create enviroment

# conda create -n openapi

# conda activate openapi

# to install the World Storage OpenAPI: cd to /CHANGE_PATH/generated folder, and then run "py-exe -m pip install ."

# then to run, activate first enviroment:

# conda activate openapi

# and then run python script:

# python <this script>.py

# See configuration.py for a list of all supported configuration parameters.

configuration = ETSI.ARF.OpenAPI.WorldStorage.Configuration(host="https://etsi.hhi.fraunhofer.de")

#configuration = ETSI.ARF.OpenAPI.WorldStorage.Configuration(host="https://localhost:44301")

#configuration = ETSI.ARF.OpenAPI.WorldStorage.Configuration(host="http://localhost:61788")

print()

print("ETSI ISG - ARF World Storage")

print()

print("Simple request tests")

print("====================")

print()

print("Using WS server: " + configuration.host)

print()

isTime = False

running = True

success = 0

#websocket = websockets.connect(my_ws_server)

myWebsocket = None

serverResponse = "None"

username = ""

msgToSend = "None"

# certificate

localhost_pem = pathlib.Path(__file__).with_name("localhost.pem")

print(f"Using PEM: {localhost_pem}")

print()

# See here: https://websockets.readthedocs.io/en/stable/howto/quickstart.html#encrypt-connections

my_ssl_context = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)

my_ssl_context.load_verify_locations(localhost_pem)

arf_ws_server = "ws://localhost:61788/ws"

#arf_ws_server = "wss://localhost:44301/ws"

#arf_ws_server = "ws://localhost:8765"

#

# Test the REST server availability

#

def CheckRESTServer(client):

    success = 0

    # Create an instance of the API class

    api_instance = default_api.DefaultApi(client)

    #

    # Endpoint: default

    #

    try:

        # Test the server availability.

        api_response = api_instance.get_ping()

        print("Sending 'ping', got response: " + api_response)

        success += 1

    except ETSI.ARF.OpenAPI.WorldStorage.ApiException as e:

        print("Exception when calling DefaultApi->get_ping: %s\n" % e)

    try:

        # Test the server availability.

        api_response = api_instance.get_version()

        print("Sending 'version', got response: " + api_response)

        success += 1

    except ETSI.ARF.OpenAPI.WorldStorage.ApiException as e:

        print("Exception when calling DefaultApi->get_ping: %s\n" % e)

    try:

        # Test the server availability.

        api_response = api_instance.get_admin()

        print("Sending 'admin', got response: " + api_response)

        success += 1

    except ETSI.ARF.OpenAPI.WorldStorage.ApiException as e:

        print("Exception when calling DefaultApi->get_ping: %s\n" % e)

    return success == 3

#

# WebSockets helpers

#

async def WS_sendNow(websocket, msg, isResponse):

    print(f"[WS] Send to server: {msg}")

    await websocket.send(msg)

    if isResponse: 

        return await WS_receive(websocket)

    return None

async def WS_receive(websocket):

    #print(f"[WS] Waiting for response...")

    msgResponse = await websocket.recv()

    WS_OnReceiveText(msgResponse);

    return msgResponse

def WS_OnReceiveText(msg):

    # Handle incoming text here?

    print(f"[WS] Received from server: {msg}")

#

# WebSockets main loop

#

async def WS_ConnectAndLoop():

    global username

    global msgToSend, serverResponse

    global running, isTime

    try:

        ###ws = websockets.WebSocket(sslopt={"cert_reqs": ssl.CERT_NONE})

        #with connect(uri=my_ws_server, ssl_context=my_ssl_context) as websocket:

        async with websockets.connect(uri=arf_ws_server) as websocket:

            #myWebsocket = websocket

            # Register the user

            print(f"[WS] Send registration request to server for {username}")

            registrationResponse = await WS_sendNow(websocket, "module:" + username, isResponse=True)

            if not registrationResponse.find("You are now registered"):

                print(f"[WS] Error: Registration of {username} was not successful!")

                return

            else:

                print(f"[WS] Registration of {username} was succesfull.")

                print(f"[WS] Entering the websockets main loop...")

            # Prepare the list of capabilities

            await WS_sendNow(websocket, "Capabilities:" + username, isResponse=True)

            msgToSend = "Time"

            #msgToSend = "Idle"

            # Receive

            while running:

                #

                # WS LOOP

                #

                if msgToSend != "None":

                    serverResponse = await WS_sendNow(websocket, msgToSend, isResponse=True)

                    # Change state

                    if msgToSend == "Time":

                        isTime = True

                        msgToSend = "None"

                    elif msgToSend == "Idle":

                        time.sleep(1)

                        '''serverResponse = await WS_sendNow(websocket, queryFirstJob, isResponse=True)

                        if serverResponse != "Job not found":

                            currentJob = Job.from_json(serverResponse)

                            currentJob.state = JobState.INITIALISING

                            currentJob.creation_time = None

                            currentJob.last_write_time = None

                            currentJob.progress = "0"

                            currentJob.result = 'Scanning location'

                            msgToSend = "UpdateJob(" + currentJob.to_json() + ")"   '''         

                        msgToSend = "Idle"

                    '''elif msgToSend == "Busy":

                        isJob = True

                        time.sleep(0.25)

                        progress = int(currentJob.progress) + 10

                        currentJob.progress = str(progress)

                        if progress >= 100:

                            if currentJob.state == JobState.INITIALISING:                                

                                currentJob.state = JobState.RUNNING

                                currentJob.result = 'Training and querying objects'

                                currentJob.progress = "0"

                            elif currentJob.state == JobState.RUNNING:

                                currentJob.state = JobState.READY

                                currentJob.result = 'Found x objects'

                                msgToSend = "idle"

                                isJob = False

                        serverResponse = await WS_sendNow(websocket, "UpdateJob(" + currentJob.to_json() + ")", isResponse=True)

'''

                if isTime:

                    serverResponse = await WS_receive(websocket)

                    if serverResponse == "TimeStop": 

                        isTime = False

                        msgToSend = "Idle"

                # Stop the loop and disconnect the server

                if msgToSend == "None" and serverResponse == "Stop":

                    running = False

    except websockets.exceptions.ConnectionClosed as e:

        print(f"[WS] Connection closed with error: {e}")

    except Exception as e:

        print(f"[WS] An error occurred: {e}")

'''

# WebSocket-Client (test)

def on_message(ws, message):

    global isJob, messageToSend

    if message == "Stop":

        ws.close()

    else:

        print(f"Received from server: {message}")

        if isJob:

            isJob = False

            print(f"Unregister me!")

            ws.send(f"UnregisterClient")

            print(f"Waiting for response...")

        else:

            isJob = True;

            messageToSend = "StartJob"

            print(f"Send to server: {messageToSend}")

            ws.send(messageToSend)

            print(f"Waiting for response...")

def on_error(ws, error):

    print(f"Encountered error: {error}")

def on_close(ws, close_status_code, close_msg):

    print("Connection closed.")

def on_open(ws):

    print()

    print(f"Send NEW registration request to server for: {username}")

    ws.send(username)

    print(f"Waiting for response...")

'''

#async def main():

def main():

    global username

    global messageToSend

    global myWebsocket

    #

    # Test rest api

    #

    api_client = ETSI.ARF.OpenAPI.WorldStorage.ApiClient(configuration)

    isServerOk = CheckRESTServer(api_client)

    if isServerOk == True:

        print ("[REST] Connection to WS was succesfull.")

    else:

        print ("[REST] Connection to WS was not succesfull!")

    #

    # Use this (websockets lib)

    #

    username = "HHI"

    messageToSend = "GetLocalisation"

    print()

    print (f"[WS] Try connecting the WA server as { username}...")

    asyncio.run(WS_ConnectAndLoop())

    #ip = input("Type <ENTER> to continue...")

    #

    # Test websockets 2

    #

    '''ws = websocket.WebSocketApp(my_ws_server,

                                on_open=on_open,

                                on_message=on_message,

                                on_error=on_error,

                                on_close=on_close)

    #ws.on_open = on_open

    ws.run_forever()'''

    print ("Exiting ARF module.")

if __name__ == "__main__":

    #asyncio.run(main())

    main()

-----BEGIN PRIVATE KEY-----

MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDG8iDak4UBpurI

TWjSfqJ0YVG/S56nhswehupCaIzu0xQ8wqPSs36h5t1jMexJPZfvwyvFjcV+hYpj

LMM0wMJPx9oBQEe0bsmlC66e8aF0UpSQw1aVfYoxA9BejgEyrFNE7cRbQNYFEb/5

3HfqZKdEQA2fgQSlZ0RTRmLrD+l72iO5o2xl5bttXpqYZB2XOkyO79j/xWdu9zFE

sgZJ5ysWbqoRAGgnxjdYYr9DARd8bIE/hN3SW7mDt5v4LqCIhGn1VmrwtT3d5AuG

QPz4YEbm0t6GOlmFjIMYH5Y7pALRVfoJKRj6DGNIR1JicL+wqLV66kcVnj8WKbla

20i7fR7NAgMBAAECggEAG5yvgqbG5xvLqlFUIyMAWTbIqcxNEONcoUAIc38fUGZr

gKNjKXNQOBha0dG0AdZSqCxmftzWdGEEfA9SaJf4YCpUz6ekTB60Tfv5GIZg6kwr

4ou6ELWD4Jmu6fC7qdTRGdgGUMQG8F0uT/eRjS67KHXbbi/x/SMAEK7MO+PRfCbj

+JGzS9Ym9mUweINPotgjHdDGwwd039VWYS+9A+QuNK27p3zq4hrWRb4wshSC8fKy

oLoe4OQt81aowpX9k6mAU6N8vOmP8/EcQHYC+yFIIDZB2EmDP07R1LUEH3KJnzo7

plCK1/kYPhX0a05cEdTpXdKa74AlvSRkS11sGqfUAQKBgQDj1SRv0AUGsHSA0LWx

a0NT1ZLEXCG0uqgdgh0sTqIeirQsPROw3ky4lH5MbjkfReArFkhHu3M6KoywEPxE

wanSRh/t1qcNjNNZUvFoUzAKVpb33RLkJppOTVEWPt+wtyDlfz1ZAXzMV66tACrx

H2a3v0ZWUz6J+x/dESH5TTNL4QKBgQDfirmknp408pwBE+bulngKy0QvU09En8H0

uvqr8q4jCXqJ1tXon4wsHg2yF4Fa37SCpSmvONIDwJvVWkkYLyBHKOns/fWCkW3n

hIcYx0q2jgcoOLU0uoaM9ArRXhIxoWqV/KGkQzN+3xXC1/MxZ5OhyxBxfPCPIYIN

YN3M1t/QbQKBgDImhsC+D30rdlmsl3IYZFed2ZKznQ/FTqBANd+8517FtWdPgnga

VtUCitKUKKrDnNafLwXrMzAIkbNn6b/QyWrp2Lln2JnY9+TfpxgJx7de3BhvZ2sl

PC4kQsccy+yAQxOBcKWY+Dmay251bP5qpRepWPhDlq6UwqzMyqev4KzBAoGAWDMi

IEO9ZGK9DufNXCHeZ1PgKVQTmJ34JxmHQkTUVFqvEKfFaq1Y3ydUfAouLa7KSCnm

ko42vuhGFB41bOdbMvh/o9RoBAZheNGfhDVN002ioUoOpSlbYU4A3q7hOtfXeCpf

lLI3JT3cFi6ic8HMTDAU4tJLEA5GhATOPr4hPNkCgYB8jTYGcLvoeFaLEveg0kS2

cz6ZXGLJx5m1AOQy5g9FwGaW+10lr8TF2k3AldwoiwX0R6sHAf/945aGU83ms5v9

PB9/x66AYtSRUos9MwB4y1ur4g6FiXZUBgTJUqzz2nehPCyGjYhh49WucjszqcjX

chS1bKZOY+1knWq8xj5Qyg==

-----END PRIVATE KEY-----

-----BEGIN CERTIFICATE-----

MIIDTTCCAjWgAwIBAgIJAOjte6l+03jvMA0GCSqGSIb3DQEBCwUAMEwxCzAJBgNV

BAYTAkZSMQ4wDAYDVQQHDAVQYXJpczEZMBcGA1UECgwQQXltZXJpYyBBdWd1c3Rp

bjESMBAGA1UEAwwJbG9jYWxob3N0MCAXDTE4MDUwNTE2NTkyOVoYDzIwNjAwNTA0

MTY1OTI5WjBMMQswCQYDVQQGEwJGUjEOMAwGA1UEBwwFUGFyaXMxGTAXBgNVBAoM

EEF5bWVyaWMgQXVndXN0aW4xEjAQBgNVBAMMCWxvY2FsaG9zdDCCASIwDQYJKoZI

hvcNAQEBBQADggEPADCCAQoCggEBAMbyINqThQGm6shNaNJ+onRhUb9LnqeGzB6G

6kJojO7TFDzCo9KzfqHm3WMx7Ek9l+/DK8WNxX6FimMswzTAwk/H2gFAR7RuyaUL

rp7xoXRSlJDDVpV9ijED0F6OATKsU0TtxFtA1gURv/ncd+pkp0RADZ+BBKVnRFNG

YusP6XvaI7mjbGXlu21emphkHZc6TI7v2P/FZ273MUSyBknnKxZuqhEAaCfGN1hi

v0MBF3xsgT+E3dJbuYO3m/guoIiEafVWavC1Pd3kC4ZA/PhgRubS3oY6WYWMgxgf

ljukAtFV+gkpGPoMY0hHUmJwv7CotXrqRxWePxYpuVrbSLt9Hs0CAwEAAaMwMC4w

LAYDVR0RBCUwI4IJbG9jYWxob3N0hwR/AAABhxAAAAAAAAAAAAAAAAAAAAABMA0G

CSqGSIb3DQEBCwUAA4IBAQC9TsTxTEvqHPUS6sfvF77eG0D6HLOONVN91J+L7LiX

v3bFeS1xbUS6/wIxZi5EnAt/te5vaHk/5Q1UvznQP4j2gNoM6lH/DRkSARvRitVc

H0qN4Xp2Yk1R9VEx4ZgArcyMpI+GhE4vJRx1LE/hsuAzw7BAdsTt9zicscNg2fxO

3ao/eBcdaC6n9aFYdE6CADMpB1lCX2oWNVdj6IavQLu7VMc+WJ3RKncwC9th+5OP

ISPvkVZWf25rR2STmvvb0qEm3CZjk4Xd7N+gxbKKUvzEgPjrLSWzKKJAWHjCLugI

/kQqhpjWVlTbtKzWz5bViqCjSbrIPpU2MgG9AUV9y3iV

-----END CERTIFICATE-----