openstudio-workflow 1.0.0.pat1 → 1.0.0

data/lib/openstudio/workflow/adapters/mongo.rb

@@ -1,227 +0,0 @@
-######################################################################
-#  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 '../adapter'
-
-module OpenStudio
-  module Workflow
-    module Adapters
-      class MongoLog
-        def initialize(datapoint_model)
-          @dp = datapoint_model
-          @dp.sdp_log_file ||= []
-        end
-
-        def write(msg)
-          @dp.sdp_log_file << msg.delete("\n")
-          @dp.save!
-        end
-      end
-
-      class Mongo < Adapter
-        attr_reader :datapoint
-
-        def initialize(options = {})
-          super
-
-          require 'mongoid'
-          require 'mongoid_paperclip'
-          require 'delayed_job_mongoid'
-          base_path = @options[:mongoid_path] ? @options[:mongoid_path] : "#{File.dirname(__FILE__)}/mongo"
-
-          Dir["#{base_path}/models/*.rb"].each { |f| require f }
-          Mongoid.load!("#{base_path}/mongoid.yml", @options[:rails_env])
-        end
-
-        # Tell the system that the process has started
-        def communicate_started(directory, options = {})
-          # Watch out for namespace conflicts (::Time is okay but Time is OpenStudio::Time)
-          File.open("#{directory}/started.job", 'w') { |f| f << "Started Workflow #{::Time.now}" }
-
-          @datapoint ||= get_datapoint_model(options[:datapoint_id])
-          @datapoint.status = 'started'
-          @datapoint.status_message = ''
-          @datapoint.run_start_time = ::Time.now
-
-          # TODO: use the ComputeNode model to pull out the information so that we can reuse the methods
-          # Determine what the IP address is of the worker node and save in the data point
-
-          # ami-id: ami-7c7e4e14
-          # instance-id: i-c52e0412
-          # instance-type: m3.medium
-          # local-hostname: ip-10-99-169-57.ec2.internal
-          # local-ipv4: 10.99.169.57
-          # placement: us-east-1a
-          # public-hostname: ec2-54-161-221-129.compute-1.amazonaws.com
-          # public-ipv4: 54.161.221.129
-          # number_of_cores: 1
-          if File.exist? '/etc/openstudio-server/instance.yml'
-            y = YAML.load_file('/etc/openstudio-server/instance.yml')
-            @datapoint.ip_address = y['public-ipv4'] if y['public-ipv4']
-            @datapoint.internal_ip_address = y['local-ipv4'] if y['local-ipv4']
-          else
-            # try to infer it from the socket/facter information
-            # note, facter will be deprecated in the future, so don't extend it!
-            retries = 0
-            begin
-              require 'socket'
-              if Socket.gethostname =~ /os-.*/
-                # Maybe use this in the future: /sbin/ifconfig eth1|grep inet|head -1|sed 's/\:/ /'|awk '{print $3}'
-                # Must be on vagrant and just use the hostname to do a lookup
-                map = {
-                  'os-server' => '192.168.33.10',
-                  'os-worker-1' => '192.168.33.11',
-                  'os-worker-2' => '192.168.33.12'
-                }
-                @datapoint.ip_address = map[Socket.gethostname]
-                @datapoint.internal_ip_address = @datapoint.ip_address
-              else
-                if Gem.loaded_specs['facter']
-                  # Use EC2 public to check if we are on AWS.
-                  @datapoint.ip_address = Facter.fact(:ec2_public_ipv4) ? Facter.fact(:ec2_public_ipv4).value : Facter.fact(:ipaddress).value
-                  @datapoint.internal_ip_address = Facter.fact(:ipaddress).value
-                end
-              end
-            rescue => e
-              # catch any exceptions. It appears that if a new instance of amazon starts, then it is likely that
-              # the Facter for AWS may not be initialized yet. Retry after waiting for 15 seconds if this happens.
-              # If this fails out, then the only issue with this is that the data point won't be downloaded because
-              # the worker node is not known
-
-              # retry just in case
-              if retries < 30 # try for up to 5 minutes
-                retries += 1
-                sleep 10
-                retry
-              else
-                raise "could not find Facter based data for worker node after #{retries} retries with message #{e.message}"
-                # just do nothing for now
-              end
-            end
-          end
-
-          @datapoint.save!
-        end
-
-        # Get the data point from the path
-        def get_datapoint(directory, options = {})
-          # TODO : make this a conditional on when to create one vs when to error out.
-          # keep @datapoint as the model instance
-          @datapoint = DataPoint.find_or_create_by(uuid: options[:datapoint_id])
-
-          # convert to JSON for the workflow - and rearrange the version (fix THIS)
-          datapoint_hash = {}
-          if @datapoint.nil?
-            fail 'Could not find datapoint'
-          else
-            datapoint_hash[:data_point] = @datapoint.as_document.to_hash
-            # TODO: Can i remove this openstudio_version stuff?
-            # datapoint_hash[:openstudio_version] = datapoint_hash[:openstudio_version]
-
-            # TODO: need to figure out how to get symbols from mongo.
-            datapoint_hash = MultiJson.load(MultiJson.dump(datapoint_hash), symbolize_keys: true)
-
-            # save to disk for inspection
-            save_dp = File.join(directory, 'data_point.json')
-            FileUtils.rm_f save_dp if File.exist? save_dp
-            File.open(save_dp, 'w') { |f| f << MultiJson.dump(datapoint_hash, pretty: true) }
-          end
-
-          datapoint_hash
-        end
-
-        # TODO: cleanup these options.  Make them part of the class. They are just unwieldly here.
-        def get_problem(directory, options = {})
-          defaults = { format: 'json' }
-          options = defaults.merge(options)
-
-          get_datapoint(directory, options) unless @datapoint
-
-          if @datapoint
-            analysis = @datapoint.analysis.as_document.to_hash
-          else
-            fail 'Cannot retrieve problem because datapoint was nil'
-          end
-
-          analysis_hash = {}
-          if analysis
-            analysis_hash[:analysis] = analysis
-            analysis_hash[:openstudio_version] = analysis[:openstudio_version]
-
-            # TODO: need to figure out how to get symbols from mongo.
-            analysis_hash = MultiJson.load(MultiJson.dump(analysis_hash, pretty: true), symbolize_keys: true)
-          end
-          analysis_hash
-        end
-
-        def communicate_intermediate_result(_directory)
-          # noop
-        end
-
-        def communicate_complete(_directory)
-          @datapoint.run_end_time = ::Time.now
-          @datapoint.status = 'completed'
-          @datapoint.status_message = 'completed normal'
-          @datapoint.save!
-        end
-
-        # Final state of the simulation. The os_directory is the run directory and may be needed to
-        # zip up the results of the simuation.
-        def communicate_failure(directory)
-          # zip up the folder even on datapoint failures
-          if directory && File.exist?(directory)
-            zip_results(directory)
-          end
-
-          @datapoint.run_end_time = ::Time.now
-          @datapoint.status = 'completed'
-          @datapoint.status_message = 'datapoint failure'
-          @datapoint.save!
-        end
-
-        def communicate_results(directory, results)
-          zip_results(directory)
-
-          # @logger.info 'Saving EnergyPlus JSON file'
-          if results
-            @datapoint.results ? @datapoint.results.merge!(results) : @datapoint.results = results
-          end
-          result = @datapoint.save! # redundant because next method calls save too.
-        end
-
-        # TODO: Implement the writing to the mongo_db for logging
-        def get_logger(directory, options = {})
-          # get the datapoint object
-          get_datapoint(directory, options) unless @datapoint
-          @log = OpenStudio::Workflow::Adapters::MongoLog.new(@datapoint)
-
-          @log
-        end
-
-        private
-
-        def get_datapoint_model(uuid)
-          # TODO : make this a conditional on when to create one vs when to error out.
-          # keep @datapoint as the model instance
-          DataPoint.find_or_create_by(uuid: uuid)
-        end
-      end
-    end
-  end
-end

data/lib/openstudio/workflow/jobs/lib/apply_measures.rb

@@ -1,253 +0,0 @@
-######################################################################
-#  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
-######################################################################
-
-# module containing the methods to apply measures to a model
-# must define the following
-#   @logger : where to log information
-#   @model : the OpenStudio model on which to apply measures
-#   @datapoint_json : the datapoint JSON
-#   @anlaysis_json : the analysis JSON
-#   @output_attributes : hash to store any output attributes
-#   @sql_filename : needed for reporting measures
-
-module OpenStudio
-  module Workflow
-    module ApplyMeasures
-      MEASURE_TYPES = {
-        openstudio_measure: 'RubyMeasure',
-        energyplus_measure: 'EnergyPlusMeasure',
-        reporting_measure: 'ReportingMeasure'
-      }
-
-      def apply_arguments(argument_map, argument)
-        success = true
-
-        unless argument[:value].nil?
-          @logger.info "Setting argument value '#{argument[:name]}' to '#{argument[:value]}'"
-
-          v = argument_map[argument[:name]]
-          fail "Could not find argument map in measure for '#{argument[:name]}' with value '#{argument[:value]}'" unless v
-          value_set = v.setValue(argument[:value])
-          fail "Could not set argument '#{argument[:name]}' of value '#{argument[:value]}' on model" unless value_set
-          argument_map[argument[:name]] = v.clone
-        else
-          @logger.warn "Value for argument '#{argument[:name]}' not set in argument list therefore will use default"
-          # success = false
-
-          # TODO: what is the fail case (success = false?)
-        end
-
-        success
-      end
-
-      # Apply the variable values to the measure argument map object
-      def apply_variables(argument_map, variable)
-        success = true
-
-        # save the uuid of the variable
-        variable_uuid = variable[:uuid].to_sym
-        if variable[:argument]
-          variable_name = variable[:argument][:name]
-
-          # Get the value from the data point json that was set via R / Problem Formulation
-          if @datapoint_json[:data_point]
-            if @datapoint_json[:data_point][:set_variable_values]
-              unless @datapoint_json[:data_point][:set_variable_values][variable_uuid].nil?
-                @logger.info "Setting variable '#{variable_name}' to #{@datapoint_json[:data_point][:set_variable_values][variable_uuid]}"
-                v = argument_map[variable_name]
-                fail 'Could not find argument map in measure' unless v
-                variable_value = @datapoint_json[:data_point][:set_variable_values][variable_uuid]
-                value_set = v.setValue(variable_value)
-                fail "Could not set variable '#{variable_name}' of value #{variable_value} on model" unless value_set
-                argument_map[variable_name] = v.clone
-              else
-                fail "[ERROR] Value for variable '#{variable_name}:#{variable_uuid}' not set in datapoint object"
-                # @logger.error "Value for variable '#{variable_name}:#{variable_uuid}' not set in datapoint object"
-                # success = false
-              end
-            else
-              fail 'No block for set_variable_values in data point record'
-            end
-          else
-            fail 'No block for data_point in data_point record'
-          end
-        else
-          fail "Variable '#{variable_name}' is defined but no argument is present"
-        end
-
-        success
-      end
-
-      def apply_measure(workflow_item)
-        @logger.info "Starting #{__method__} for #{workflow_item[:name]}"
-        @time_logger.start("Measure:#{workflow_item[:name]}")
-        # start_time = ::Time.now
-        current_dir = Dir.pwd
-        begin
-          measure_working_directory = "#{@run_directory}/#{workflow_item[:measure_definition_class_name]}"
-
-          @logger.info "Creating run directory to #{measure_working_directory}"
-          FileUtils.mkdir_p measure_working_directory
-          Dir.chdir measure_working_directory
-
-          measure_path = workflow_item[:measure_definition_directory]
-          measure_name = workflow_item[:measure_definition_class_name]
-          @logger.info "Apply measure running in #{Dir.pwd}"
-
-          measure_file_path = nil
-          if (Pathname.new measure_path).absolute?
-            measure_file_path = measure_path
-          else
-            measure_file_path = File.expand_path(File.join(@options[:analysis_root_path], measure_path, 'measure.rb'))
-          end
-
-          @logger.info "Loading Measure from #{measure_file_path}"
-          fail "Measure file does not exist #{measure_name} in #{measure_file_path}" unless File.exist? measure_file_path
-
-          measure = nil
-          runner = nil
-          result = nil
-          begin
-            require measure_file_path
-            measure = Object.const_get(measure_name).new
-            runner = ExtendedRunner.new(@logger, @analysis_json, @datapoint_json)
-            runner.former_workflow_arguments = @workflow_arguments
-            runner.past_results = @past_results
-          rescue => e
-            log_message = "Error requiring measure #{__FILE__}. Failed with #{e.message}, #{e.backtrace.join("\n")}"
-            raise log_message
-          end
-
-          arguments = nil
-
-          begin
-            if workflow_item[:measure_type] == 'RubyMeasure'
-              arguments = measure.arguments(@model)
-            elsif workflow_item[:measure_type] == 'EnergyPlusMeasure'
-              arguments = measure.arguments(@model)
-            elsif workflow_item[:measure_type] == 'ReportingMeasure'
-              arguments = measure.arguments
-            end
-
-            # Create argument map and initialize all the arguments
-            argument_map = OpenStudio::Ruleset::OSArgumentMap.new
-            if arguments
-              arguments.each do |v|
-                argument_map[v.name] = v.clone
-              end
-            end
-            # @logger.info "Argument map for measure is #{argument_map}"
-
-            @logger.info "Iterating over arguments for workflow item '#{workflow_item[:name]}'"
-            if workflow_item[:arguments]
-              workflow_item[:arguments].each do |argument|
-                success = apply_arguments(argument_map, argument)
-                fail 'Could not set arguments' unless success
-              end
-            end
-
-            @logger.info "Iterating over variables for workflow item '#{workflow_item[:name]}'"
-            if workflow_item[:variables]
-              workflow_item[:variables].each do |variable|
-                success = apply_variables(argument_map, variable)
-                fail 'Could not set variables' unless success
-              end
-            end
-          rescue => e
-            log_message = "Error assigning argument in measure #{__FILE__}. Failed with #{e.message}, #{e.backtrace.join("\n")}"
-            raise log_message
-          end
-
-          begin
-            @logger.info "Calling measure.run for '#{workflow_item[:name]}'"
-            if workflow_item[:measure_type] == 'RubyMeasure'
-              measure.run(@model, runner, argument_map)
-            elsif workflow_item[:measure_type] == 'EnergyPlusMeasure'
-              runner.setLastOpenStudioModel(@model)
-              measure.run(@model_idf, runner, argument_map)
-            elsif workflow_item[:measure_type] == 'ReportingMeasure'
-              # This is silly, set the last model, last IDF, and last sqlfile instead of passing it into the measure.run method
-              runner.setLastOpenStudioModel(@model)
-              runner.setLastEnergyPlusWorkspace(@model_idf)
-              runner.setLastEnergyPlusSqlFilePath(@sql_filename)
-
-              measure.run(runner, argument_map)
-            end
-            @workflow_arguments[workflow_item[:name].to_sym] = runner.workflow_arguments
-            @logger.info "Finished measure.run for '#{workflow_item[:name]}'"
-
-            # run garbage collector after every measure to help address race conditions
-            GC.start
-          rescue => e
-            log_message = "Runner error #{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
-            raise log_message
-          end
-
-          begin
-            result = runner.result
-            @logger.info "Running of measure '#{workflow_item[:name]}' completed. Post-processing measure output"
-
-            fail "Measure #{measure_name} reported an error, check log" if result.errors.size != 0
-          rescue => e
-            log_message = "Runner error #{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
-            raise log_message
-          end
-
-          begin
-            measure_attributes = JSON.parse(OpenStudio.toJSON(result.attributes), symbolize_names: true)
-            @output_attributes[workflow_item[:name].to_sym] = measure_attributes[:attributes]
-            @past_results[workflow_item[:name].to_sym] = measure_attributes[:attributes]
-
-            # add an applicability flag to all the measure results
-            @output_attributes[workflow_item[:name].to_sym][:applicable] = result.value.value != -1
-            @past_results[workflow_item[:name].to_sym][:applicable] = result.value.value != -1
-          rescue => e
-            log_message = "#{__FILE__} failed with #{e.message}, #{e.backtrace.join("\n")}"
-            @logger.error log_message
-          end
-        rescue => e
-          log_message = "#{__FILE__} failed with message #{e.message} in #{e.backtrace.join("\n")}"
-          @logger.error log_message
-          raise log_message
-        ensure
-          Dir.chdir current_dir
-          @time_logger.stop("Measure:#{workflow_item[:name]}")
-
-          @logger.info "Finished #{__method__} for #{workflow_item[:name]} in #{@time_logger.delta("Measure:#{workflow_item[:name]}")} s"
-        end
-      end
-
-      def apply_measures(measure_type)
-        if @analysis_json[:analysis][:problem] && @analysis_json[:analysis][:problem][:workflow]
-          current_dir = Dir.pwd
-          begin
-            @logger.info "Applying measures for #{MEASURE_TYPES[measure_type]}"
-            @analysis_json[:analysis][:problem][:workflow].each do |wf|
-              next unless wf[:measure_type] == MEASURE_TYPES[measure_type]
-
-              apply_measure(wf)
-            end
-          ensure
-            Dir.chdir current_dir
-          end
-        end
-      end
-    end
-  end
-end