openstudio-workflow 1.0.0.pat1 → 1.0.0

data/lib/openstudio/workflow_json.rb

@@ -0,0 +1,399 @@
+######################################################################
+#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.
+#  All rights reserved.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+######################################################################
+
+require 'pathname'
+
+# Optional_Shim provides a wrapper that looks like an OpenStudio Optional
+class Optional_Shim
+  def initialize(obj)
+    @obj = obj
+  end
+
+  def empty?
+    @obj.nil?
+  end
+
+  def is_initialized
+    !@obj.nil?
+  end
+
+  def get
+    raise 'Uninitialized Optional_Shim' if @obj.nil?
+    @obj
+  end
+end
+
+s = ''
+unless s.respond_to?(:to_StepResult)
+  class String
+    def to_StepResult
+      self
+    end
+  end
+end
+unless s.respond_to?(:to_VariantType)
+  class String
+    def to_VariantType
+      self
+    end
+  end
+end
+
+# WorkflowStepResultValue_Shim provides a shim interface to the WorkflowStepResultValue class in OpenStudio 2.X when running in OpenStudio 1.X
+class WorkflowStepResultValue_Shim
+  def initialize(name, value, type)
+    @name = name
+    @value = value
+    @type = type
+  end
+
+  attr_reader :name
+
+  attr_reader :value
+
+  def variantType
+    @type
+  end
+
+  def valueAsString
+    @value.to_s
+  end
+
+  def valueAsDouble
+    @value.to_f
+  end
+
+  def valueAsInteger
+    @value.to_i
+  end
+
+  def valueAsBoolean
+    @value
+  end
+end
+
+# WorkflowStepResult_Shim provides a shim interface to the WorkflowStepResult class in OpenStudio 2.X when running in OpenStudio 1.X
+class WorkflowStepResult_Shim
+  def initialize(result)
+    @result = result
+  end
+
+  def stepErrors
+    return @result[:step_errors]
+  end
+
+  def stepWarnings
+    return @result[:step_warnings]
+  end
+
+  def stepInfo
+    return @result[:step_info]
+  end
+
+  def stepValues
+    result = []
+    @result[:step_values].each do |step_value|
+      result << WorkflowStepResultValue_Shim.new(step_value[:name], step_value[:value], step_value[:type])
+    end
+    return result
+  end
+
+  def stepResult
+    Optional_Shim.new(@result[:step_result])
+  end
+  
+   def setStepResult(step_result)
+    @result[:step_result] = step_result
+  end 
+end
+
+# WorkflowStep_Shim provides a shim interface to the WorkflowStep class in OpenStudio 2.X when running in OpenStudio 1.X
+class WorkflowStep_Shim
+  def initialize(step)
+    @step = step
+  end
+
+  attr_reader :step
+
+  def result
+    if @step[:result]
+      Optional_Shim.new(WorkflowStepResult_Shim.new(@step[:result]))
+    else
+      Optional_Shim.new
+    end
+  end
+
+  # std::string measureDirName() const;
+  def measureDirName
+    @step[:measure_dir_name]
+  end
+
+  # std::map<std::string, Variant> arguments() const;
+  def arguments
+    # TODO: match C++
+    @step[:arguments]
+  end
+end
+
+# WorkflowJSON_Shim provides a shim interface to the WorkflowJSON class in OpenStudio 2.X when running in OpenStudio 1.X
+class WorkflowJSON_Shim
+  def initialize(workflow, osw_dir)
+    @workflow = workflow
+    @osw_dir = osw_dir
+    @current_step_index = 0
+  end
+
+  # std::string string(bool includeHash=true) const;
+  def string
+    JSON.fast_generate(@workflow)
+  end
+  
+  def timeString
+    ::Time.now.utc.strftime("%Y%m%dT%H%M%SZ")
+  end
+
+  # Returns the absolute path to the directory this workflow was loaded from or saved to.  Returns current working dir for new WorkflowJSON.
+  # openstudio::path oswDir() const;
+  def oswDir
+    OpenStudio.toPath(@osw_dir)
+  end
+
+  def saveAs(path)
+    File.open(path.to_s, 'w') do |file|
+      file << JSON.pretty_generate(@workflow)
+    end
+  end
+
+  # Sets the started at time.
+  def start
+    @workflow[:started_at] = timeString
+  end
+
+  # Get the current step index.
+  def currentStepIndex
+    @current_step_index
+  end
+
+  # Get the current step.
+  # boost::optional<WorkflowStep> currentStep() const;
+  def currentStep
+    steps = @workflow[:steps]
+
+    step = nil
+    if @current_step_index < steps.size
+      step = WorkflowStep_Shim.new(steps[@current_step_index])
+    end
+    return Optional_Shim.new(step)
+  end
+
+  # Increments current step, returns true if there is another step.
+  # bool incrementStep();
+  def incrementStep
+    @current_step_index += 1
+
+    if @current_step_index < @workflow[:steps].size
+      return true
+    end
+
+    return false
+  end
+
+  # Returns the root directory, default value is '.'. Evaluated relative to oswDir if not absolute.
+  # openstudio::path rootDir() const;
+  # openstudio::path absoluteRootDir() const;
+  def rootDir
+    if @workflow[:root_dir]
+      OpenStudio.toPath(@workflow[:root_dir])
+    else
+      OpenStudio.toPath(@osw_dir)
+    end
+  end
+
+  def absoluteRootDir
+    OpenStudio.toPath(File.absolute_path(rootDir.to_s, @osw_dir.to_s))
+  end
+
+  # Returns the run directory, default value is './run'. Evaluated relative to rootDir if not absolute.
+  # openstudio::path runDir() const;
+  # openstudio::path absoluteRunDir() const;
+  def runDir
+    if @workflow[:run_directory]
+      OpenStudio.toPath(@workflow[:run_directory])
+    else
+      OpenStudio.toPath('./run')
+    end
+  end
+
+  def absoluteRunDir
+    OpenStudio.toPath(File.absolute_path(runDir.to_s, rootDir.to_s))
+  end
+
+  def outPath
+    if @workflow[:out_name]
+      OpenStudio.toPath(@workflow[:out_name])
+    else
+      OpenStudio.toPath('./out.osw')
+    end
+  end
+
+  def absoluteOutPath
+    OpenStudio.toPath(File.absolute_path(outPath.to_s, oswDir.to_s))
+  end
+
+  # Returns the paths that will be searched in order for files, default value is './files/'. Evaluated relative to rootDir if not absolute.
+  # std::vector<openstudio::path> filePaths() const;
+  # std::vector<openstudio::path> absoluteFilePaths() const;
+  def filePaths
+    result = OpenStudio::PathVector.new
+    if @workflow[:file_paths]
+      @workflow[:file_paths].each do |file_path|
+        result << OpenStudio.toPath(file_path)
+      end
+    else
+      result << OpenStudio.toPath('./files')
+      result << OpenStudio.toPath('./weather')
+      result << OpenStudio.toPath('../../files')
+      result << OpenStudio.toPath('../../weather')
+      result << OpenStudio.toPath('./')
+    end
+    result
+  end
+
+  def absoluteFilePaths
+    result = OpenStudio::PathVector.new
+    filePaths.each do |file_path|
+      result << OpenStudio.toPath(File.absolute_path(file_path.to_s, rootDir.to_s))
+    end
+    result
+  end
+
+  # Attempts to find a file by name, searches through filePaths in order and returns first match.
+  # boost::optional<openstudio::path> findFile(const openstudio::path& file);
+  # boost::optional<openstudio::path> findFile(const std::string& fileName);
+  def findFile(file)
+    file = file.to_s
+
+    # check if absolute and exists
+    if Pathname.new(file).absolute?
+      if File.exist?(file)
+        return OpenStudio::OptionalPath.new(OpenStudio.toPath(file))
+      end
+
+      # absolute path does not exist
+      return OpenStudio::OptionalPath.new
+    end
+
+    absoluteFilePaths.each do |file_path|
+      result = File.join(file_path.to_s, file)
+      if File.exist?(result)
+        return OpenStudio::OptionalPath.new(OpenStudio.toPath(result))
+      end
+    end
+    OpenStudio::OptionalPath.new
+  end
+
+  # Returns the paths that will be searched in order for measures, default value is './measures/'. Evaluated relative to rootDir if not absolute.
+  # std::vector<openstudio::path> measurePaths() const;
+  # std::vector<openstudio::path> absoluteMeasurePaths() const;
+  def measurePaths
+    result = OpenStudio::PathVector.new
+    if @workflow[:measure_paths]
+      @workflow[:measure_paths].each do |measure_path|
+        result << OpenStudio.toPath(measure_path)
+      end
+    else
+      result << OpenStudio.toPath('./measures')
+      result << OpenStudio.toPath('../../measures')
+      result << OpenStudio.toPath('./')
+    end
+    result
+  end
+
+  def absoluteMeasurePaths
+    result = OpenStudio::PathVector.new
+    measurePaths.each do |measure_path|
+      result << OpenStudio.toPath(File.absolute_path(measure_path.to_s, rootDir.to_s))
+    end
+    result
+  end
+
+  # Attempts to find a measure by name, searches through measurePaths in order and returns first match. */
+  # boost::optional<openstudio::path> findMeasure(const openstudio::path& measureDir);
+  # boost::optional<openstudio::path> findMeasure(const std::string& measureDirName);
+  def findMeasure(measureDir)
+    measureDir = measureDir.to_s
+
+    # check if absolute and exists
+    if Pathname.new(measureDir).absolute?
+      if File.exist?(measureDir)
+        return OpenStudio::OptionalPath.new(OpenStudio.toPath(measureDir))
+      end
+
+      # absolute path does not exist
+      return OpenStudio::OptionalPath.new
+    end
+
+    absoluteMeasurePaths.each do |measure_path|
+      result = File.join(measure_path.to_s, measureDir)
+      if File.exist?(result)
+        return OpenStudio::OptionalPath.new(OpenStudio.toPath(result))
+      end
+    end
+    OpenStudio::OptionalPath.new
+  end
+
+  # Returns the seed file path. Evaluated relative to filePaths if not absolute.
+  # boost::optional<openstudio::path> seedFile() const;
+  def seedFile
+    result = OpenStudio::OptionalPath.new
+    if @workflow[:seed_file]
+      result = OpenStudio::OptionalPath.new(OpenStudio.toPath(@workflow[:seed_file]))
+    end
+    result
+  end
+
+  # Returns the weather file path. Evaluated relative to filePaths if not absolute.
+  # boost::optional<openstudio::path> weatherFile() const;
+  def weatherFile
+    result = OpenStudio::OptionalPath.new
+    if @workflow[:weather_file]
+      result = OpenStudio::OptionalPath.new(OpenStudio.toPath(@workflow[:weather_file]))
+    end
+    result
+  end
+
+  # Returns the workflow steps. */
+  # std::vector<WorkflowStep> workflowSteps() const;
+  def workflowSteps
+    result = []
+    @workflow[:steps].each do |step|
+      result << WorkflowStep_Shim.new(step)
+    end
+    result
+  end
+
+  def setCompletedStatus(status)
+    @workflow[:completed_status] = status
+    @workflow[:completed_at] = timeString
+  end
+  
+  def setEplusoutErr(eplusout_err)
+    @workflow[:eplusout_err] = eplusout_err
+  end
+end

data/lib/openstudio/workflow_runner.rb

@@ -0,0 +1,213 @@
+######################################################################
+#  Copyright (c) 2008-2014, Alliance for Sustainable Energy.
+#  All rights reserved.
+#
+#  This library is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU Lesser General Public
+#  License as published by the Free Software Foundation; either
+#  version 2.1 of the License, or (at your option) any later version.
+#
+#  This library is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+#  Lesser General Public License for more details.
+#
+#  You should have received a copy of the GNU Lesser General Public
+#  License along with this library; if not, write to the Free Software
+#  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+######################################################################
+
+require_relative 'workflow_json'
+
+# Extend OS Runner to persist measure information throughout the workflow
+# Provide shims to support OpenStudio 2.X functionality in OpenStudio 1.X
+class WorkflowRunner < OpenStudio::Ruleset::OSRunner
+  def initialize(multi_logger, workflow_json, openstudio_2)
+    @multi_logger = multi_logger
+    @workflow_json = workflow_json
+    @openstudio_2 = openstudio_2
+
+    begin
+      # OpenStudio 2.X
+      super(@workflow_json)
+    rescue Exception => e
+      # OpenStudio 1.X
+      @workflow = workflow_json
+      @units_preference = 'SI'
+      @language_preference = 'EN'
+      super()
+    end
+  end
+  
+  def timeString
+    ::Time.now.utc.strftime("%Y%m%dT%H%M%SZ")
+  end
+  
+  # Returns the workflow currently being run. New in OS 2.0.
+  # WorkflowJSON workflow() const;
+  def workflow
+    if @openstudio_2
+      super
+    else
+      @workflow
+    end
+  end
+
+  # Returns preferred unit system, either 'IP' or 'SI'. New in OS 2.0. */
+  # std::string unitsPreference() const;
+  def unitsPreference
+    if @openstudio_2
+      super
+    else
+      @units_preference
+    end
+  end
+
+  # Returns preferred language, e.g. 'en' or 'fr'. New in OS 2.0. */
+  # std::string languagePreference() const;
+  def languagePreference
+    if @openstudio_2
+      super
+    else
+      @language_preference
+    end
+  end
+
+  # called right when each measure is run
+  # only called in OpenStudio 1.X
+  # virtual void prepareForUserScriptRun(const UserScript& userScript);
+  def prepareForUserScriptRun(userScript)
+    if @openstudio_2
+      prepareForMeasureRun(userScript)
+    else
+      current_step = @workflow.currentStep
+
+      unless current_step.empty?
+        current_step.get.step[:result] = {}
+        current_step.get.step[:result][:started_at] = timeString
+      end
+
+      # TODO: capture std out and err
+
+      # TODO: get initial list of files
+
+      super
+    end
+  end
+
+  def result
+    if @openstudio_2
+      super
+    else
+      os_result = super
+
+      current_step = @workflow.currentStep
+
+      if current_step.empty?
+        raise 'Cannot find current_step'
+      end
+      current_step = current_step.get
+
+      if current_step.step[:result].nil?
+        # skipped, prepareForUserScriptRun was not called
+        current_step.step[:result] = {}
+        current_step.step[:result][:started_at] = timeString
+        current_step.step[:result][:step_result] = 'Skip'
+      else
+        current_step.step[:result][:step_result] = os_result.value.valueName
+      end
+
+      current_step.step[:result][:completed_at] = timeString
+
+      # TODO: restore stdout and stderr
+
+      # TODO: check for created files
+
+      current_step.step[:result][:step_errors] = []
+      os_result.errors.each do |error|
+        current_step.step[:result][:step_errors] << error.logMessage
+      end
+
+      current_step.step[:result][:step_warnings] = []
+      os_result.warnings.each do |warning|
+        current_step.step[:result][:step_warnings] << warning.logMessage
+      end
+
+      current_step.step[:result][:step_info] = []
+      os_result.info.each do |info|
+        current_step.step[:result][:step_info] << info.logMessage
+      end
+
+      unless os_result.initialCondition.empty?
+        current_step.step[:result][:initial_condition] = os_result.initialCondition.get.logMessage
+      end
+
+      unless os_result.finalCondition.empty?
+        current_step.step[:result][:final_condition] = os_result.finalCondition.get.logMessage
+      end
+
+      current_step.step[:result][:step_values] = []
+      os_result.attributes.each do |attribute|
+        result = nil
+        if attribute.valueType == 'Boolean'.to_AttributeValueType
+          result = { name: attribute.name, value: attribute.valueAsBoolean, type: 'Boolean' }
+        elsif attribute.valueType == 'Double'.to_AttributeValueType
+          result = { name: attribute.name, value: attribute.valueAsDouble, type: 'Double' }
+        elsif attribute.valueType == 'Integer'.to_AttributeValueType
+          result = { name: attribute.name, value: attribute.valueAsInteger, type: 'Integer' }
+        elsif attribute.valueType == 'Unsigned'.to_AttributeValueType
+          result = { name: attribute.name, value: attribute.valueAsUnsigned, type: 'Integer' }
+        elsif attribute.valueType == 'String'.to_AttributeValueType
+          result = { name: attribute.name, value: attribute.valueAsString, type: 'String' }
+        end
+
+        current_step.step[:result][:step_values] << result unless result.nil?
+      end
+
+      return WorkflowStepResult_Shim.new(current_step.step[:result])
+    end
+  end
+
+  # incrementing step copies result to previous results
+  # void incrementStep();
+  def incrementStep
+    if @openstudio_2
+      super
+    else
+      # compute result
+      current_result = result
+
+      @workflow.incrementStep
+    end
+  end
+
+  # Overload registerInfo
+  def registerInfo(message)
+    super
+    @multi_logger.info message
+  end
+
+  # Overload registerInfo
+  def registerWarning(message)
+    super
+    @multi_logger.warn message
+  end
+
+  # Overload registerError
+  def registerError(message)
+    super
+    @multi_logger.error message
+  end
+
+  # Overload registerInitialCondition
+  def registerInitialCondition(message)
+    super
+    @multi_logger.info message
+  end
+
+  # Overload registerFinalCondition
+  def registerFinalCondition(message)
+    super
+    @multi_logger.info message
+  end
+end