Configuring Dropbox Uploads from Ignition Perspective via Flask

Where does each piece run before you write any code?

The operator drops a file on a Perspective File Upload component and expects it in a Dropbox folder. The file makes four hops to get there, and most failures happen at a hop the operator never sees. Ignition scripting runs on Jython, which cannot load the CPython Dropbox SDK and its dependencies. For that reason the working build puts the SDK in a small Flask service. Getting the Perspective upload event to pass raw file bytes straight to Flask did not work either. The build that does work writes the upload to a temporary folder and sends Flask only the file's path. Flask then opens that file from disk and uploads it.

Handing off a path only works when Flask and the Gateway see the same filesystem. Co-locating them is the configuration that works as written. The downside is that at scale a Python service on the Gateway host competes with Ignition for CPU and memory. If you move Flask to another host, you have to replace the path handoff with a shared folder that both service accounts can reach, or send the file bytes in the request body. You also have to rebind Flask off loopback and put TLS on the link.

Check before moving on:

1. Create C:/temp/dropbox_upload and C:/temp/dropbox_download on the Gateway host.
2. Find the account the Ignition Gateway service runs as (Windows Services console). Grant it write access to the upload folder.
3. Grant the account that will run Flask read access to the upload folder and write access to the download folder.

How do you get a Dropbox token that outlives the first session?

Dropbox issues short-lived access tokens. A service that stores only the access token works during commissioning and then returns authentication errors later. Request offline access so the OAuth flow also returns a refresh token. The service trades that refresh token for new access tokens with no operator involved.

1. In the Dropbox developer console, create an app with Scoped access and Full Dropbox access.
2. On the Permissions tab, enable files.metadata.read, files.metadata.write, files.content.read, files.content.write. Submit the permissions before you authorize. A token carries only the scopes that were granted when it was issued, so any scope you add later requires re-running the auth flow.
3. Record the App Key and App Secret. Keep them out of the Ignition project and out of source control.
4. On the Gateway host, install the packages with pip install dropbox flask under Python 3.x.
5. Run the one-time auth script. It builds DropboxOAuth2FlowNoRedirect(APP_KEY, APP_SECRET, token_access_type='offline') and prints an authorize URL. Open the URL, click Allow, and paste the code back into the script. The script then writes access_token and refresh_token to dropbox_token.json.

Check: open dropbox_token.json and confirm that refresh_token is present and non-empty. If it is missing, the flow ran without token_access_type='offline'.

How should the Flask bridge hold and refresh the token?

The starting version of app.py loads the stored access token and calls users_get_current_account() before every request. On AuthError it refreshes by building a client from the refresh token and reading the private attribute _oauth2_access_token. That works, but it has four weak spots:

• Every upload costs an extra Dropbox round trip just to probe the token.
• Reading _oauth2_access_token depends on SDK internals that can change between releases.
• TOKEN_FILE = "dropbox_token.json" is a relative path. If Flask starts from another working directory, for example as a scheduled task or a service, it finds no file, sets dbx = None, and returns 401 until someone restarts it.
• file_path comes from the request body unchecked. Any caller that reaches the port can make Flask upload any file the Flask account can read.

A Dropbox client built with oauth2_refresh_token, app_key and app_secret refreshes its own access token when it expires. Build it once and drop the probe:

The /upload exception handler also returns 200 with success: false. Add , 500 to that return so the HTTP status code agrees with the body.

Check: start python app.py, place test.txt in the upload folder, and put this body in body.json:

{"path": "/TestFolder/test.txt", "file_path": "C:/temp/dropbox_upload/test.txt"}

Run curl -X POST http://127.0.0.1:9876/upload -H "Content-Type: application/json" --data @body.json. Expect "success": true and "file_path": "/TestFolder/test.txt". Until this passes, Ignition is not part of the problem.

Why system.net.httpClient and not system.net.httpPost?

Trying to post this request with system.net.httpPost cost a full day of troubleshooting. Moving to system.net.httpClient() fixed it. The client's post() serializes a dict passed as data into a JSON body. It also returns a response object for every status code, including 4xx and 5xx. That means the Flask error JSON reaches your script and you can read it through .json, .statusCode and .text. Create one client at library level and reuse it.

Put the following in a Project Library script named dropbox_rest. Two changes from the starting version: the temp file name carries a UUID prefix, so two operators uploading the same file name at the same moment do not overwrite each other's staged copy, and the staged file is deleted afterward. Without the delete, C:/temp/dropbox_upload keeps growing.

Dropbox paths must begin with /. Pass /TestFolder, not TestFolder.

Check: do not use the Designer Script Console for this test unless the Designer is running on the Gateway host. The console runs in designer scope, so 127.0.0.1 points at the engineering laptop, and there is no event.file to pass. Test from the component in a live session (next section) and read the result in the Gateway logs under Status > Diagnostics > Logs, filtered on Dropbox.

How do you wire the File Upload component so the operator sees the result?

If the result only goes to the log, the screen looks the same whether the upload succeeded or failed. Write the result back to the view. The label name below is an example; use whatever label you have on the view.

def runAction(self, event):
    result = dropbox_rest.uploadFileToDropbox(event, '/TestFolder')
    lbl = self.getSibling('lblUploadStatus')
    if result.get('success'):
        lbl.props.text = 'Saved to ' + result.get('file_path')
    else:
        lbl.props.text = 'Upload failed: ' + str(result.get('error'))

Put this in the component's onFileReceived event. The event runs on the Gateway no matter where the browser is, so a Perspective session on another PC or a panel stages the file on the Gateway host. The same 127.0.0.1 call still reaches Flask. Also check the component's maximum file size property. It rejects oversize files in the browser before your script ever runs.

Check: upload a small text file from a session. Expect Saved to /TestFolder/<name> on the label, the file in Dropbox, and an empty C:/temp/dropbox_upload.

Why does the Download button do nothing on screen?

The download path works; the button never uses what it gets back. The starting button script calls dropbox_rest.downloadFileFromDropbox() and ignores the return value, so the file reaches Flask, then the Gateway, and stops there. A second problem: system.net.httpGet returns text, which corrupts binary files such as PDFs, images and recipe archives. Fetch the response as bytes and push them to the browser:

# dropbox_rest
import java.net.URLEncoder

def downloadFileFromDropbox(dropbox_path):
    url = API + '/download?dropbox_path=' + java.net.URLEncoder.encode(dropbox_path, 'UTF-8')
    resp = client.get(url)
    if resp.statusCode != 200:
        logger.error('Download failed: %s' % resp.text)
        return None
    return resp.body

# Download button, onActionPerformed
def runAction(self, event):
    dropbox_path = '/TestFolder/TestFile_1.txt'
    data = dropbox_rest.downloadFileFromDropbox(dropbox_path)
    if data:
        system.perspective.download(dropbox_path.split('/')[-1], data)

Flask also leaves every downloaded file in C:/temp/dropbox_download. Schedule a cleanup for that folder or delete each file after send_file returns.

Check: click the button in a session. The browser should save the file, and a binary file should open without errors.

What is the screen telling you when a transfer fails?

How do you prove the whole chain end to end?

1. Restart Flask from a different working directory than app.py. A clean start shows the absolute TOKEN_FILE fix is in place.
2. Confirm debug=False and that Flask listens only on 127.0.0.1:9876.
3. Replay the curl test, then send a file_path outside the upload folder. Expect the 400 rejection.
4. From a Perspective session on a PC other than the Gateway, upload a text file and a binary file. Expect the success label, both files in Dropbox, and an empty upload folder.
5. Upload the same file name again and confirm the Dropbox result matches the write mode you chose.
6. Leave Flask running longer than the access-token lifetime, then upload again with nobody logged in on the Gateway host. A success confirms that the refresh token renews the session with no operator involved.
7. Download the binary file through the button on the remote session and open it. A clean open confirms every hop, from browser to Gateway to Flask to Dropbox and back, carries bytes intact.

FAQ