Merge pull request #2529 from pypeclub/feature/OP-2360_Validate-if-cu…

…rrent-OpenPype-version-is-production-version

General: Validate if current process OpenPype version is requested version

openpype/lib/__init__.py

@@ -168,9 +168,13 @@
  make_sequence_collection
 )
 
-from .pype_info import (
+from .openpype_version import (
  get_openpype_version,
- get_build_version
+ get_build_version,
+ get_expected_version,
+ is_running_from_build,
+ is_running_staging,
+ is_current_version_studio_latest
 )
 
 terminal = Terminal
@@ -304,4 +308,8 @@
 
  "get_openpype_version",
  "get_build_version",
+ "get_expected_version",
+ "is_running_from_build",
+ "is_running_staging",
+ "is_current_version_studio_latest",
 ]

openpype/lib/openpype_version.py

@@ -9,9 +9,69 @@
 repository or locally available.
 """
 
+import os
 import sys
 
+import openpype.version
 
+from .python_module_tools import import_filepath
+
+
+# ----------------------------------------
+# Functions independent on OpenPypeVersion
+# ----------------------------------------
+def get_openpype_version():
+ """Version of pype that is currently used."""
+ return openpype.version.__version__
+
+
+def get_build_version():
+ """OpenPype version of build."""
+ # Return OpenPype version if is running from code
+ if not is_running_from_build():
+ return get_openpype_version()
+
+ # Import `version.py` from build directory
+ version_filepath = os.path.join(
+ os.environ["OPENPYPE_ROOT"],
+ "openpype",
+ "version.py"
+ )
+ if not os.path.exists(version_filepath):
+ return None
+
+ module = import_filepath(version_filepath, "openpype_build_version")
+ return getattr(module, "__version__", None)
+
+
+def is_running_from_build():
+ """Determine if current process is running from build or code.
+
+ Returns:
+ bool: True if running from build.
+ """
+ executable_path = os.environ["OPENPYPE_EXECUTABLE"]
+ executable_filename = os.path.basename(executable_path)
+ if "python" in executable_filename.lower():
+ return False
+ return True
+
+
+def is_running_staging():
+ """Currently used OpenPype is staging version.
+
+ Returns:
+ bool: True if openpype version containt 'staging'.
+ """
+ if "staging" in get_openpype_version():
+ return True
+ return False
+
+
+# ----------------------------------------
+# Functions dependent on OpenPypeVersion
+# - Make sense to call only in OpenPype process
+# ----------------------------------------
 def get_OpenPypeVersion():
  """Access to OpenPypeVersion class stored in sys modules."""
  return sys.modules.get("OpenPypeVersion")
@@ -71,15 +131,67 @@ def get_remote_versions(*args, **kwargs):
  return None
 
 
-def get_latest_version(*args, **kwargs):
+def get_latest_version(staging=None, local=None, remote=None):
  """Get latest version from repository path."""
+ if staging is None:
+ staging = is_running_staging()
  if op_version_control_available():
- return get_OpenPypeVersion().get_latest_version(*args, **kwargs)
+ return get_OpenPypeVersion().get_latest_version(
+ staging=staging,
+ local=local,
+ remote=remote
+ )
  return None
 
 
-def get_expected_studio_version(staging=False):
+def get_expected_studio_version(staging=None):
  """Expected production or staging version in studio."""
+ if staging is None:
+ staging = is_running_staging()
  if op_version_control_available():
  return get_OpenPypeVersion().get_expected_studio_version(staging)
  return None
+
+
+def get_expected_version(staging=None):
+ expected_version = get_expected_studio_version(staging)
+ if expected_version is None:
+ # Look for latest if expected version is not set in settings
+ expected_version = get_latest_version(
+ staging=staging,
+ remote=True
+ )
+ return expected_version
+
+
+def is_current_version_studio_latest():
+ """Is currently running OpenPype version which is defined by studio.
+
+ It is not recommended to ask in each process as there may be situations
+ when older OpenPype should be used. For example on farm. But it does make
+ sense in processes that can run for a long time.
+
+ Returns:
+ None: Can't determine. e.g. when running from code or the build is
+ too old.
+ bool: True when is using studio
+ """
+ output = None
+ # Skip if is not running from build or build does not support version
+ # control or path to folder with zip files is not accessible
+ if (
+ not is_running_from_build()
+ or not op_version_control_available()
+ or not openpype_path_is_accessible()
+ ):
+ return output
+
+ # Get OpenPypeVersion class
+ OpenPypeVersion = get_OpenPypeVersion()
+ # Convert current version to OpenPypeVersion object
+ current_version = OpenPypeVersion(version=get_openpype_version())
+
+ # Get expected version (from settings)
+ expected_version = get_expected_version()
+ # Check if current version is expected version
+ return current_version == expected_version

openpype/lib/pype_info.py

@@ -5,68 +5,13 @@
 import getpass
 import socket
 
-import openpype.version
 from openpype.settings.lib import get_local_settings
 from .execute import get_openpype_execute_args
 from .local_settings import get_local_site_id
-from .python_module_tools import import_filepath
-
-
-def get_openpype_version():
- """Version of pype that is currently used."""
- return openpype.version.__version__
-
-
-def get_pype_version():
- """Backwards compatibility. Remove when 100% not used."""
- print((
- "Using deprecated function 'openpype.lib.pype_info.get_pype_version'"
- " replace with 'openpype.lib.pype_info.get_openpype_version'."
- ))
- return get_openpype_version()
-
-
-def get_build_version():
- """OpenPype version of build."""
- # Return OpenPype version if is running from code
- if not is_running_from_build():
- return get_openpype_version()
-
- # Import `version.py` from build directory
- version_filepath = os.path.join(
- os.environ["OPENPYPE_ROOT"],
- "openpype",
- "version.py"
- )
- if not os.path.exists(version_filepath):
- return None
-
- module = import_filepath(version_filepath, "openpype_build_version")
- return getattr(module, "__version__", None)
-
-
-def is_running_from_build():
- """Determine if current process is running from build or code.
-
- Returns:
- bool: True if running from build.
- """
- executable_path = os.environ["OPENPYPE_EXECUTABLE"]
- executable_filename = os.path.basename(executable_path)
- if "python" in executable_filename.lower():
- return False
- return True
-
-
-def is_running_staging():
- """Currently used OpenPype is staging version.
-
- Returns:
- bool: True if openpype version containt 'staging'.
- """
- if "staging" in get_openpype_version():
- return True
- return False
+from .openpype_version import (
+ is_running_from_build,
+ get_openpype_version
+)
 
 
 def get_pype_info():

openpype/modules/default_modules/ftrack/scripts/sub_event_status.py

@@ -16,8 +16,14 @@
  TOPIC_STATUS_SERVER_RESULT
 )
 from openpype.api import Logger
+from openpype.lib import (
+ is_current_version_studio_latest,
+ is_running_from_build,
+ get_expected_version,
+ get_openpype_version
+)
 
-log = Logger().get_logger("Event storer")
+log = Logger.get_logger("Event storer")
 action_identifier = (
  "event.server.status" + os.environ["FTRACK_EVENT_SUB_ID"]
 )
@@ -203,8 +209,57 @@ def bool_items(self):
  })
  return items
 
+ def openpype_version_items(self):
+ items = []
+ is_latest = is_current_version_studio_latest()
+ items.append({
+ "type": "label",
+ "value": "# OpenPype version"
+ })
+ if not is_running_from_build():
+ items.append({
+ "type": "label",
+ "value": (
+ "OpenPype event server is running from code <b>{}</b>."
+ ).format(str(get_openpype_version()))
+ })
+
+ elif is_latest is None:
+ items.append({
+ "type": "label",
+ "value": (
+ "Can't determine if OpenPype version is outdated"
+ " <b>{}</b>. OpenPype build version should be updated."
+ ).format(str(get_openpype_version()))
+ })
+ elif is_latest:
+ items.append({
+ "type": "label",
+ "value": "OpenPype version is up to date <b>{}</b>.".format(
+ str(get_openpype_version())
+ )
+ })
+ else:
+ items.append({
+ "type": "label",
+ "value": (
+ "Using <b>outdated</b> OpenPype version <b>{}</b>."
+ " Expected version is <b>{}</b>."
+ "<br/>- Please restart event server for automatic"
+ " updates or update manually."
+ ).format(
+ str(get_openpype_version()),
+ str(get_expected_version())
+ )
+ })
+
+ items.append({"type": "label", "value": "---"})
+
+ return items
+
  def items(self):
  items = []
+ items.extend(self.openpype_version_items())
  items.append(self.note_item)
  items.extend(self.bool_items())
 

openpype/resources/__init__.py

@@ -1,5 +1,5 @@
 import os
-from openpype.lib.pype_info import is_running_staging
+from openpype.lib.openpype_version import is_running_staging
 
 RESOURCES_DIR = os.path.dirname(os.path.abspath(__file__))
 

openpype/settings/defaults/system_settings/general.json

@@ -4,6 +4,7 @@
  "admin_password": "",
  "production_version": "",
  "staging_version": "",
+ "version_check_interval": 5,
  "environment": {
  "__environment_keys__": {
  "global": []

openpype/settings/entities/schemas/system_schema/schema_general.json

@@ -47,6 +47,19 @@
  {
  "type": "splitter"
  },
+ {
+ "type": "label",
+ "label": "Trigger validation if running OpenPype is using studio defined version each 'n' <b>minutes</b>. Validation happens in OpenPype tray application."
+ },
+ {
+ "type": "number",
+ "key": "version_check_interval",
+ "label": "Version check interval",
+ "minimum": 0
+ },
+ {
+ "type": "splitter"
+ },
  {
  "key": "environment",
  "label": "Environment",

openpype/style/data.json

@@ -51,6 +51,8 @@
  "border-hover": "rgba(168, 175, 189, .3)",
  "border-focus": "rgb(92, 173, 214)",
 
+ "restart-btn-bg": "#458056",
+
  "delete-btn-bg": "rgb(201, 54, 54)",
  "delete-btn-bg-disabled": "rgba(201, 54, 54, 64)",
 

openpype/style/style.css

@@ -1228,6 +1228,11 @@ QScrollBar::add-page:vertical, QScrollBar::sub-page:vertical {
  background: #21252B;
 }
 
+/* Tray */
+#TrayRestartButton {
+ background: {color:restart-btn-bg};
+}
+
 /* Globally used names */
 #Separator {
  background: {color:bg-menu-separator};