Module: DriverExecHelper

Included in:
OpenNebulaDriver
Defined in:
lib/DriverExecHelper.rb

Overview

This module provides an abstraction to generate an execution context for OpenNebula Drivers. The module has been designed to be included as part of a driver and not to be used standalone.

Constant Summary collapse

RESULT =

Action result strings for messages

{
    :success => "SUCCESS",
    :failure => "FAILURE"
}

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.failed?(rc_str) ⇒ Boolean

Returns:

  • (Boolean) 


27
28
29
 
# File 'lib/DriverExecHelper.rb', line 27

def self.failed?(rc_str)
    return rc_str == RESULT[:failure]
end

Instance Method Details

#action_command_line(action, parameters, default_name = nil, directory = '') ⇒ String

METHODS FOR COMMAND LINE & ACTION PATHS

Given the action name and the parameter returns full path of the script and appends its parameters. It uses @local_actions hash to know if the actions is remote or local. If the local actions has defined an special script name this is used, otherwise the action name in downcase is used as the script name.

Parameters:

  • action (String, Symbol) —

    name of the action

  • parameters (String) —

    arguments for the script

  • default_name (String, nil) (defaults to: nil) —

    alternative name for the script

  • directory (String, '') (defaults to: '') —

    to append to the scripts path for actions

Returns:

  • (String) —

    command line needed to execute the action



66
67
68
69
70
71
72
73
74
75
 
# File 'lib/DriverExecHelper.rb', line 66

def action_command_line(action, parameters, default_name=nil, directory='')
    if action_is_local? action
        script_path=File.join(@local_scripts_path, directory)
    else
        script_path=File.join(@remote_scripts_path, directory)
    end

    File.join(script_path, action_script_name(action, default_name))+
        " "+parameters
end

#action_is_local?(action) ⇒ Boolean

True if the action is meant to be executed locally

Parameters:

  • action (String, Symbol) —

    name of the action

Returns:

  • (Boolean) 


80
81
82
 
# File 'lib/DriverExecHelper.rb', line 80

def action_is_local?(action)
    @local_actions.include? action.to_s.upcase
end

#action_script_name(action, default_name = nil) ⇒ Object

Name of the script file for the given action

Parameters:

  • action (String, Symbol) —

    name of the action

  • default_name (String, nil) (defaults to: nil) —

    alternative name for the script



88
89
90
91
92
93
94
95
96
 
# File 'lib/DriverExecHelper.rb', line 88

def action_script_name(action, default_name=nil)
    name=@local_actions[action.to_s.upcase]

    if name
        name
    else
        default_name || action.to_s.downcase
    end
end

#get_info_from_execution(command_exe) ⇒ Object

This method returns the result in terms



153
154
155
156
157
158
159
160
161
162
163
164
165
 
# File 'lib/DriverExecHelper.rb', line 153

def get_info_from_execution(command_exe)
    if command_exe.code == 0
        result = RESULT[:success]
        info   = command_exe.stdout
    else
        result = RESULT[:failure]
        info   = command_exe.get_error_message
    end

    info = "-" if info == nil || info.empty?

    [result, info]
end

#initialize_helper(directory, options) ⇒ Object

Initialize module variables



32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
 
# File 'lib/DriverExecHelper.rb', line 32

def initialize_helper(directory, options)
    @config = read_configuration
    @remote_scripts_base_path = @config['SCRIPTS_REMOTE_DIR']

    @local_actions = options[:local_actions]

    if ENV['ONE_LOCATION'].nil?
        @local_scripts_base_path = '/var/lib/one/remotes'
    else
        @local_scripts_base_path = "#{ENV['ONE_LOCATION']}/var/remotes"
    end

    # dummy paths
    @remote_scripts_path = File.join(@remote_scripts_base_path, directory)
    @local_scripts_path  = File.join(@local_scripts_base_path, directory)

    # mutex for logging
    @send_mutex = Mutex.new
end

#log(number, message, all = true) ⇒ Object

Sends a log message to ONE. The message can be multiline, it will be automatically splitted by lines.



111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
 
# File 'lib/DriverExecHelper.rb', line 111

def log(number, message, all=true)
    in_error_message=false
    msg=message.strip
    msg.each_line {|line|
        severity=all ? 'I' : nil
        l=line.strip

        if l=='ERROR MESSAGE --8<------'
            in_error_message=true
            next
        elsif l=='ERROR MESSAGE ------>8--'
            in_error_message=false
            next
        else
            if in_error_message
                severity='E'
            elsif line.match(/^(ERROR|DEBUG|INFO):(.*)$/)
                line=$2
                case $1
                when 'ERROR'
                    severity='E'
                when 'DEBUG'
                    severity='D'
                when 'INFO'
                    severity='I'
                end
            end
        end

        send_message("LOG", severity, number, line.strip) if severity
    }
end

#log_method(num) ⇒ Object

Generates a proc with that calls log with a hardcoded number. It will be used to add loging to command actions



146
147
148
149
150
 
# File 'lib/DriverExecHelper.rb', line 146

def log_method(num)
    lambda {|message, all=true|
        log(num, message, all)
    }
end

#read_configuration ⇒ Object

Simple parser for the config file generated by OpenNebula



170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
 
# File 'lib/DriverExecHelper.rb', line 170

def read_configuration
    one_config=nil

    if ENV['ONE_LOCATION']
        one_config = ENV['ONE_LOCATION']+'/var/config'
    else
        one_config = '/var/lib/one/config'
    end

    config = {}
    cfg    = ''

    begin
        File.open(one_config, 'r') do |file|
            cfg=file.read
        end

        cfg.split(/\n/).each do |line|
            m=line.match(/^([^=]+)=(.*)$/)

            next unless m

            name  = m[1].strip.upcase
            value = m[2].strip

            if config[name]
                if config[name].instance_of? Array
                    config[name] << value
                else
                    config[name] = [config[name], value]
                end
            else
                config[name]=value
            end
        end
    rescue StandardException => e
        STDERR.puts "Error reading config: #{e.inspect}"
        STDERR.flush
    end

    config
end

#send_message(action = "-", result = RESULT[:failure], id = "-", info = "-") ⇒ Object

METHODS FOR LOGS & COMMAND OUTPUT

Sends a message to the OpenNebula core through stdout



102
103
104
105
106
107
 
# File 'lib/DriverExecHelper.rb', line 102

def send_message(action="-", result=RESULT[:failure], id="-", info="-")
    @send_mutex.synchronize {
        STDOUT.puts "#{action} #{result} #{id} #{info}"
        STDOUT.flush
    }
end