This file is indexed.

/usr/lib/one/ruby/OpenNebulaJSON/JSONUtils.rb is in ruby-opennebula 3.2.1-2.

This file is owned by root:root, with mode 0o644.

The actual contents of the file can be viewed below.

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
# -------------------------------------------------------------------------- #
# Copyright 2002-2012, OpenNebula Project Leads (OpenNebula.org)             #
#                                                                            #
# Licensed under the Apache License, Version 2.0 (the "License"); you may    #
# not use this file except in compliance with the License. You may obtain    #
# a copy of the License at                                                   #
#                                                                            #
# http://www.apache.org/licenses/LICENSE-2.0                                 #
#                                                                            #
# Unless required by applicable law or agreed to in writing, software        #
# distributed under the License is distributed on an "AS IS" BASIS,          #
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
# See the License for the specific language governing permissions and        #
# limitations under the License.                                             #
#--------------------------------------------------------------------------- #

module OpenNebulaJSON

    require 'json'

    module JSONUtils
        def to_json
            begin
                JSON.pretty_generate self.to_hash
            rescue Exception => e
                OpenNebula::Error.new(e.message)
            end
        end

        def parse_json(json_str, root_element)
            begin
                hash = JSON.parse(json_str)
            rescue Exception => e
                return OpenNebula::Error.new(e.message)
            end

            if hash.has_key?(root_element)
                return hash[root_element]
            else
                return OpenNebula::Error.new("Error parsing JSON: Wrong resource type")
            end
        end

        def parse_json_sym(json_str, root_element)
            begin
                parser = JSON.parser.new(json_str, {:symbolize_names => true})
                hash = parser.parse

                if hash.has_key?(root_element)
                    return hash[root_element]
                end

                Error.new("Error parsing JSON:\ root element not present")

            rescue => e
                Error.new(e.message)
            end
        end

        def template_to_str(attributes, indent=true)
             if indent
                 ind_enter="\n"
                 ind_tab='  '
             else
                 ind_enter=''
                 ind_tab=' '
             end

             str=attributes.collect do |key, value|
                 if value
                     str_line=""
                     if value.class==Array && !value.empty?
                         value.each do |value2|
                             str_line << key.to_s.upcase << "=[" << ind_enter
                             if value2 && value2.class==Hash
                                 str_line << value2.collect do |key3, value3|
                                     str = ind_tab + key3.to_s.upcase + "="
                                     str += "\"#{value3.to_s}\"" if value3
                                     str
                                 end.compact.join(",\n")
                             end
                             str_line << "\n]\n"
                         end

                     elsif value.class==Hash && !value.empty?
                         str_line << key.to_s.upcase << "=[" << ind_enter

                         str_line << value.collect do |key3, value3|
                             str = ind_tab + key3.to_s.upcase + "="
                             str += "\"#{value3.to_s}\"" if value3
                             str
                         end.compact.join(",\n")

                         str_line << "\n]\n"

                     else
                         str_line<<key.to_s.upcase << "=" << "\"#{value.to_s}\""
                     end
                     str_line
                 end
             end.compact.join("\n")

             str
         end
     end
end