132 lines
4.4 KiB
Python
Executable File
132 lines
4.4 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import json
|
|
import logging
|
|
import os
|
|
import platform
|
|
import shlex
|
|
import shutil
|
|
import struct
|
|
import subprocess
|
|
import sys
|
|
from pathlib import Path
|
|
|
|
def which(command):
|
|
if os.getenv("FLATPAK_ID"):
|
|
try:
|
|
return subprocess.check_output(["flatpak-spawn", "--host", "which", command]).decode().strip()
|
|
except subprocess.CalledProcessError:
|
|
pass
|
|
path = shutil.which(command)
|
|
if path != "":
|
|
return path
|
|
else:
|
|
return None
|
|
|
|
|
|
JABREF_PATH = ""
|
|
if os.getenv("FLATPAK_ID"):
|
|
try:
|
|
subprocess.check_output(["flatpak-spawn", "--host", "true"])
|
|
except subprocess.CalledProcessError:
|
|
logging.error("Failed to call JabRef: Flatpak browser missing permissions")
|
|
send_message({"message": "flatpakPermissionsError", "output": "Flatpak browser missing permissions"})
|
|
exit(-1)
|
|
JABREF_PATH = "flatpak-spawn --host "
|
|
|
|
# Try a set of possible launchers to execute JabRef
|
|
script_dir = Path(__file__).resolve().parent.parent
|
|
relpath_path = str(script_dir / "bin/JabRef")
|
|
lowercase_path = which("jabref")
|
|
uppercase_path = which("JabRef")
|
|
|
|
# Relative path used in the portable install
|
|
if which(relpath_path) is not None:
|
|
JABREF_PATH += relpath_path
|
|
# Lowercase launcher used in deb/rpm/snap packages
|
|
elif lowercase_path is not None:
|
|
JABREF_PATH += lowercase_path
|
|
# Uppercase launcher used in Arch AUR package
|
|
elif uppercase_path is not None:
|
|
JABREF_PATH += uppercase_path
|
|
# FLatpak support
|
|
elif which("/var/lib/flatpak/exports/bin/org.jabref.jabref") is not None:
|
|
JABREF_PATH += "/var/lib/flatpak/exports/bin/org.jabref.jabref"
|
|
else:
|
|
logging.error("Could not determine JABREF_PATH")
|
|
sys.exit(-1)
|
|
|
|
logging_dir = Path.home() / ".mozilla/native-messaging-hosts/"
|
|
if not logging_dir.exists():
|
|
logging_dir.mkdir(parents=True)
|
|
logging.basicConfig(filename=str(logging_dir / "jabref_browser_extension.log"))
|
|
|
|
# Read a message from stdin and decode it.
|
|
def get_message():
|
|
raw_length = sys.stdin.buffer.read(4)
|
|
if not raw_length:
|
|
logging.error("Raw_length null")
|
|
sys.exit(0)
|
|
message_length = struct.unpack("=I", raw_length)[0]
|
|
logging.info("Got length: {} bytes to be read".format(message_length))
|
|
message = sys.stdin.buffer.read(message_length).decode("utf-8")
|
|
logging.info("Got message of {} chars".format(len(message)))
|
|
data = json.loads(message)
|
|
logging.info("Successfully retrieved JSON")
|
|
return data
|
|
|
|
|
|
# Encode a message for transmission, given its content.
|
|
def encode_message(message_content):
|
|
encoded_content = json.dumps(message_content).encode("utf-8")
|
|
encoded_length = struct.pack("=I", len(encoded_content))
|
|
return {
|
|
"length": encoded_length,
|
|
"content": struct.pack(str(len(encoded_content)) + "s", encoded_content),
|
|
}
|
|
|
|
|
|
# Send an encoded message to stdout.
|
|
def send_message(message):
|
|
encoded_message = encode_message(message)
|
|
sys.stdout.buffer.write(encoded_message["length"])
|
|
sys.stdout.buffer.write(encoded_message["content"])
|
|
sys.stdout.buffer.flush()
|
|
|
|
|
|
def add_jabref_entry(data):
|
|
"""Send string via cli as literal to preserve special characters"""
|
|
cmd = str(JABREF_PATH).split() + ["--importBibtex", r"{}".format(data)]
|
|
logging.info("Try to execute command {}".format(cmd))
|
|
response = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
|
logging.info("Called JabRef and got: {}".format(response))
|
|
return response
|
|
|
|
|
|
logging.info("Starting JabRef backend")
|
|
|
|
try:
|
|
message = get_message()
|
|
except Exception as e:
|
|
message = str(e)
|
|
logging.info(str(message))
|
|
|
|
if "status" in message and message["status"] == "validate":
|
|
cmd = str(JABREF_PATH).split() + ["--version"]
|
|
try:
|
|
response = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
|
|
except subprocess.CalledProcessError as exc:
|
|
logging.error("Failed to call JabRef: {} {}".format(exc.returncode, exc.output))
|
|
send_message({"message": "jarNotFound", "path": JABREF_PATH})
|
|
else:
|
|
logging.info("Response: {}".format(response))
|
|
send_message({"message": "jarFound"})
|
|
else:
|
|
entry = message["text"]
|
|
try:
|
|
output = add_jabref_entry(entry)
|
|
send_message({"message": "ok", "output": str(output)})
|
|
except subprocess.CalledProcessError as exc:
|
|
logging.error("Failed to call JabRef: {} {}".format(exc.returncode, exc.output))
|
|
send_message({"message": "error", "output": str(exc.output)})
|