class Orocos::Process

# File lib/orocos/process.rb, line 872
def self.allocate_gdb_port
    @@gdb_port += 1
end

# File lib/orocos/process.rb, line 385
def self.deregister(pid)
    if process = registered_processes.delete(pid)
        process
    else raise ArgumentError, "no process registered for PID #{pid}"
    end
end

# File lib/orocos/process.rb, line 395
def self.each(&block)
    registered_processes.each_value(&block)
end

# File lib/orocos/process.rb, line 352
def self.from_pid(pid)
    if result = registered_processes[pid]
        return result
    end
end

# File lib/orocos/process.rb, line 867
def self.gdb_base_port=(port)
    @@gdb_port = port - 1
end

# File lib/orocos/process.rb, line 697
def self.has_command?(cmd)
    if File.file?(cmd) && File.executable?(cmd)
        return
    else
        system("which #{cmd} > /dev/null 2>&1")
    end
end

# File lib/orocos/process.rb, line 860
def self.kill(processes, wait = true)
    processes.each { |p| p.kill if p.running? }
    if wait
        processes.each { |p| p.join }
    end
end

# File lib/orocos/process.rb, line 423
def initialize(name, model = name,
        loader: Orocos.default_pkgconfig_loader,
        name_mappings: Hash.new)
    model = if model.respond_to?(:to_str)
                loader.deployment_model_from_name(model)
            else model
            end
    
    @binfile =
        if loader.respond_to?(:find_deployment_binfile)
            loader.find_deployment_binfile(model.name)
        else loader.available_deployments[model.name].binfile
        end
    super(name, model, name_mappings: name_mappings)
end

# File lib/orocos/process.rb, line 571
def self.normalize_wait_option(wait, valgrind, gdb)
    if wait.nil?
        wait =
            if valgrind then 600
            elsif gdb then 600
            else 20
            end
    elsif !wait
        false
    else wait
    end
end

# File lib/orocos/process.rb, line 732
def self.parse_cmdline_wrapper_option(cmd, deployments, options, all_deployments)
    if !deployments
        return Hash.new
    end

    if !has_command?(cmd)
        raise "'#{cmd}' option is specified, but #{cmd} seems not to be installed"
    end

    if !deployments.respond_to?(:to_hash)
        if deployments.respond_to?(:to_str)
            deployments = [deployments]
        elsif !deployments.respond_to?(:to_ary)
            deployments = all_deployments
        end

        deployments = deployments.inject(Hash.new) { |h, name| h[name] = options; h }
    end
    deployments.each_key do |name|
        if !all_deployments.include?(name)
            raise ArgumentError, "#{name}, selected to be executed under #{cmd}, is not a known deployment/model"
        end
    end
end

# File lib/orocos/process.rb, line 686
def self.parse_log_level_option( options, all_deployments )
    if !options.respond_to?(:to_hash)
        all_deployments.inject(Hash.new) { |h, name| h[name] = options; h }
    else
        options
    end
end

# File lib/orocos/process.rb, line 638
def self.parse_run_options(*names, wait: nil, loader: Orocos.default_loader,
                           valgrind: false, valgrind_options: Hash.new,
                           gdb: false, gdb_options: Hash.new,
                           log_level: nil,
                           output: nil, oro_logfile:  "orocos.%m-%p.txt",
                           working_directory: Orocos.default_working_directory,
                           cmdline_args: Hash.new)
    deployments, models = partition_run_options(*names, loader: loader)
    wait = normalize_wait_option(wait, valgrind, gdb)

    all_deployments = deployments.keys.map(&:name) + models.values.flatten
    valgrind = parse_cmdline_wrapper_option(
        'valgrind', valgrind, valgrind_options, all_deployments)
    gdb = parse_cmdline_wrapper_option(
        'gdbserver', gdb, gdb_options, all_deployments)
    log_level = parse_log_level_option(log_level, all_deployments)

    name_mappings = resolve_name_mappings(deployments, models)
    processes = name_mappings.map do |deployment_name, mappings, name|
        output = if output
                     output.gsub '%m', name
                 end

        spawn_options = Hash[
            working_directory: working_directory,
            output: output,
            valgrind: valgrind[name],
            gdb: gdb[name],
            cmdline_args: cmdline_args,
            wait: false,
            log_level: log_level[name],
            oro_logfile: oro_logfile]
        [deployment_name, mappings, name, spawn_options]
    end
    return processes, wait
end

# File lib/orocos/process.rb, line 529
def self.partition_run_options(*names, loader: Orocos.default_loader)
    mapped_names = Hash.new
    if names.last.kind_of?(Hash)
        mapped_names = names.pop
    end

    deployments, models = Hash.new, Hash.new
    names.each { |n| mapped_names[n] = nil }
    mapped_names.each do |object, new_name|
        # If given a name, resolve to the corresponding oroGen spec
        # object
        if object.respond_to?(:to_str) || object.respond_to?(:to_sym)
            object = object.to_s
            begin
                object = loader.task_model_from_name(object)
            rescue OroGen::NotFound
                begin
                    object = loader.deployment_model_from_name(object)
                rescue OroGen::NotFound
                    raise OroGen::NotFound, "#{object} is neither a task model nor a deployment name"
                end
            end
        end

        case object
        when OroGen::Spec::TaskContext
            if !new_name
                raise TaskNameRequired, "you must provide a task name when starting a component by type, as e.g. Orocos.run 'xsens_imu::Task' => 'xsens'"
            end
            models[object] = Array(new_name)
        when OroGen::Spec::Deployment
            deployments[object] = (new_name if new_name)
        else raise ArgumentError, "expected a task context model or a deployment model, got #{object}"
        end
    end
    return deployments, models
end

# File lib/orocos/process.rb, line 374
def self.register(process)
    if !process.alive?
        raise ArgumentError, "cannot register a non-running process"
    end
    registered_processes[process.pid] = process
    nil
end

# File lib/orocos/process.rb, line 1149
def self.resolve_all_tasks(process, cache = Hash.new)
    # Get any task name from that specific deployment, and check we
    # can access it. If there is none
    all_reachable = process.task_names.all? do |task_name|
        begin
            cache[task_name] ||= yield(task_name)
        rescue Orocos::NotFound
        end
    end
    if all_reachable
        cache
    end
end

# File lib/orocos/process.rb, line 771
def self.resolve_name_mappings(deployments, models)
    processes = []
    processes += deployments.map do |deployment, prefix|
        mapped_name   = deployment.name
        name_mappings = Hash.new
        if prefix
            name_mappings = ProcessBase.resolve_prefix(deployment, prefix)
            mapped_name = "#{prefix}#{deployment.name}"
        end

        [deployment.name, name_mappings, mapped_name]
    end
    models.each do |model, desired_names|
        desired_names = [desired_names] unless desired_names.kind_of? Array 
        desired_names.each do |desired_name|
            process_name = OroGen::Spec::Project.default_deployment_name(model.name)
            name_mappings = Hash[
                process_name => desired_name,
                "#{process_name}_Logger" => "#{desired_name}_Logger"]

            processes << [process_name, name_mappings, desired_name]
        end
    end
    processes
end

# File lib/orocos/process.rb, line 798
def self.run(*args, **options)
    if !Orocos.initialized?
        #try to initialize orocos before bothering the user
        Orocos.initialize
    end
    if !Orocos::CORBA.initialized?
        raise "CORBA layer is not initialized! There might be problem with the installation."
    end

    begin
        process_specs, wait = parse_run_options(*args, **options)

        # Then spawn them, but without waiting for them
        processes = process_specs.map do |deployment_name, name_mappings, name, spawn_options|
            p = Process.new(name, deployment_name)
            name_mappings.each do |old, new|
                p.map_name old, new
            end
            p.spawn(spawn_options)
            p
        end

        # Finally, if the user required it, wait for the processes to run
        if wait
            timeout = if wait.kind_of?(Numeric)
                          wait
                      else Float::INFINITY
                      end
            processes.each { |p| p.wait_running(timeout) }
        end

    rescue Exception => original_error
        # Kill the processes that are already running
        if processes
            begin
                kill(processes.map { |p| p if p.running? }.compact)
            rescue Exception => e
                Orocos.warn "failed to kill the started processes, you will have to kill them yourself"
                Orocos.warn e.message
                e.backtrace.each do |l|
                    Orocos.warn "  #{l}"
                end
                raise original_error
            end
        end
        raise
    end

    if block_given?
        Orocos.guard(*processes) do
            yield(*processes)
        end
    else
        processes
    end
end

# File lib/orocos/process.rb, line 1243
def self.try_task_cleanup(task)
    begin
        task.stop(false)
        if task.model && task.model.needs_configuration?
            task.cleanup(false)
        end
    rescue StateTransitionFailed
    end

    task.each_port do |port|
        port.disconnect_all
    end

    true

rescue Exception => e
    Orocos.warn "clean shutdown of #{task.name} failed: #{e.message}"
    e.backtrace.each do |line|
        Orocos.warn line
    end
    false
end

# File lib/orocos/process.rb, line 1165
def self.wait_running(process, timeout = nil, name_service = Orocos::CORBA.name_service, &block)
    if timeout == 0
        return nil if !process.alive?

        # Use custom block to check if the process is reachable
        if block_given?
            block.call(process)
        else
            # Get any task name from that specific deployment, and check we
            # can access it. If there is none
            all_reachable = process.task_names.all? do |task_name|
                if name_service.task_reachable?(task_name)
                    Orocos.debug "#{task_name} is reachable"
                    true
                else
                    Orocos.debug "could not access #{task_name}, #{name} is not running yet ..."
                    false
                end
            end
            if all_reachable
                Orocos.info "all tasks of #{process.name} are reachable, assuming it is up and running"
            end
            all_reachable
        end
    else
        start_time = Time.now
        got_alive = process.alive?
        while true
            if wait_running(process, 0, name_service, &block)
                break
            elsif not timeout
                break
            elsif timeout < Time.now - start_time
                break
            end

            if got_alive && !process.alive?
                raise Orocos::NotFound, "#{process.name} was started but crashed"
            end
            sleep 0.1
        end

        if process.alive?
            return true
        else
            raise Orocos::NotFound, "cannot get a running #{process.name} module"
        end
    end
end

# File lib/orocos/process.rb, line 455
def alive?; !!@pid end

# File lib/orocos/process.rb, line 883
def command_line(working_directory: Orocos.default_working_directory,
        log_level: nil,
        cmdline_args: Hash.new,
        tracing: Orocos.tracing?,
        gdb: nil, valgrind: nil,
        name_service_ip: Orocos::CORBA.name_service_ip)

    result = CommandLine.new(Hash.new, nil, [], working_directory)
    result.command = binfile

    if tracing
        result.env['LD_PRELOAD'] = Orocos.tracing_library_path
    end
    if log_level
        valid_levels = [:debug, :info, :warn, :error, :fatal, :disable]
        if valid_levels.include?(log_level)
            result.env['BASE_LOG_LEVEL'] = log_level.to_s.upcase
        else
            raise ArgumentError, "'#{log_level}' is not a valid log level." +
                " Valid options are #{valid_levels}."
        end
    end
    if name_service_ip
        result.env['ORBInitRef'] = "NameService=corbaname::#{name_service_ip}"
    end

    cmdline_args = cmdline_args.dup
    cmdline_args[:rename] ||= []
    name_mappings.each do |old, new|
        cmdline_args[:rename].push "#{old}:#{new}"
    end

    # Command line arguments have to be of type --<option>=<value>
    # or if <value> is nil a valueless option, i.e. --<option>
    cmdline_args.each do |option, value|
        if value
            if value.respond_to?(:to_ary)
                value.each do |v|
                    result.args.push "--#{option}=#{v}"
                end
            else
                result.args.push "--#{option}=#{value}"
            end
        else
            result.args.push "--#{option}"
        end
    end

    if gdb
        result.args.unshift(result.command)
        if gdb == true
            gdb = Process.allocate_gdb_port
        end
        result.args.unshift("0.0.0.0:#{gdb}")
        result.command = 'gdbserver'
    elsif valgrind
        result.args.unshift(result.command)
        result.command = 'valgrind'
    end

    return result
end

# File lib/orocos/process.rb, line 401
def host_id
    'localhost'
end

# File lib/orocos/process.rb, line 443
def join
    return unless alive?

    begin
        ::Process.waitpid(pid)
        exit_status = $?
        dead!(exit_status)
    rescue Errno::ECHILD
    end
end

# File lib/orocos/process.rb, line 1268
def kill(wait = true, signal = nil)
    tpid = pid
    return if !tpid # already dead

    # Stop all tasks and disconnect the ports
    if !signal
        clean_shutdown = true
        begin
            each_task do |task|
                if !self.class.try_task_cleanup(task)
                    clean_shutdown = false
                    break
                end
            end
        rescue Orocos::NotFound, Orocos::NoModel
            # We're probably still starting the process. Just go on and
            # signal it
            clean_shutdown = false
        end
        if !clean_shutdown
            Orocos.warn "clean shutdown of process #{name} failed"
        end
    end

    expected_exit = nil
    if clean_shutdown
        expected_exit = signal = SIGNAL_NUMBERS['SIGINT']
    else
        signal = SIGNAL_NUMBERS['SIGINT']
    end

    if signal 
        if !expected_exit
            Orocos.warn "sending #{signal} to #{name}"
        end

        if signal.respond_to?(:to_str) && signal !~ /^SIG/
            signal = "SIG#{signal}"
        end

        expected_exit ||=
            if signal.kind_of?(Integer) then signal
            else SIGNAL_NUMBERS[signal] || signal
            end

        @expected_exit = expected_exit
        begin
            ::Process.kill(signal, tpid)
        rescue Errno::ESRCH
            # Already exited
            return
        end
    end

    if wait
        join
        if @exit_status && @exit_status.signaled?
            if !expected_exit
                Orocos.warn "#{name} unexpectedly exited with signal #{@exit_status.termsig}"
            elsif @exit_status.termsig != expected_exit
                Orocos.warn "#{name} was expected to quit with signal #{expected_exit} but terminated with signal #{@exit_status.termsig}"
            end
        end
    end
end

# File lib/orocos/process.rb, line 407
def on_localhost?
    host_id == 'localhost'
end

# File lib/orocos/process.rb, line 1215
def resolve_all_tasks(cache = Hash.new, name_service: Orocos::CORBA.name_service)
    Process.resolve_all_tasks(self, cache) do |task_name|
        name_service.get(task_name)
    end
end

# File lib/orocos/process.rb, line 457
def running?; alive? end

# File lib/orocos/process.rb, line 977
def spawn(log_level: nil, working_directory: Orocos.default_working_directory,
          cmdline_args: Hash.new,
          oro_logfile:  "orocos.%m-%p.txt",
          prefix: nil, tracing: Orocos.tracing?, name_service: Orocos::CORBA.name_service,
          wait: nil,
          output: nil,
          gdb: nil, valgrind: nil)

    raise "#{name} is already running" if alive?
    Orocos.info "starting deployment #{name}"

    # Setup mapping for prefixed tasks in Process class
    prefix_mappings = ProcessBase.resolve_prefix(model, prefix)
    name_mappings = prefix_mappings.merge(self.name_mappings)
    self.name_mappings = name_mappings

    # If possible, check that we won't clash with an already running
    # process
    task_names.each do |name|
        if name_service.task_reachable?(name)
            raise ArgumentError, "there is already a running task called #{name}, are you starting the same component twice ?"
        end
    end

    if wait.nil?
        wait =
            if valgrind then 600
            elsif gdb then 600
            else 20
            end
    end

    cmdline_args = cmdline_args.dup
    cmdline_args[:rename] ||= []
    name_mappings.each do |old, new|
        cmdline_args[:rename].push "#{old}:#{new}"
    end

    if valgrind
        cmdline_wrapper = 'valgrind'
        cmdline_wrapper_options =
            if valgrind.respond_to?(:to_ary)
                valgrind
            else []
            end
    elsif gdb
        cmdline_wrapper = 'gdbserver'
        cmdline_wrapper_options =
            if gdb.respond_to?(:to_ary)
                gdb
            else []
            end
        gdb_port = Process.allocate_gdb_port
        cmdline_wrapper_options << "localhost:#{gdb_port}"
    end

    if !name_service.ip.empty?
        ENV['ORBInitRef'] = "NameService=corbaname::#{name_service.ip}"
    end

    cmdline = [binfile]

    # check arguments for log_level
    if log_level
        valid_levels = [:debug, :info, :warn, :error, :fatal, :disable]
        if valid_levels.include?(log_level)
            log_level = log_level.to_s.upcase
        else
            raise ArgumentError, "'#{log_level}' is not a valid log level." +
                " Valid options are #{valid_levels}."
        end
    end
            
    read, write = IO.pipe
    @pid = fork do 
        if tracing
            ENV['LD_PRELOAD'] = Orocos.tracing_library_path
        end

        pid = ::Process.pid
        real_name = get_mapped_name(name)

        ENV['BASE_LOG_LEVEL'] = log_level if log_level

        if output && output.respond_to?(:to_str)
            output_file_name = output.
                gsub('%m', real_name).
                gsub('%p', pid.to_s)
            if working_directory
                output_file_name = File.expand_path(output_file_name, working_directory)
            end

            output = File.open(output_file_name, 'a')
        end

        if oro_logfile
            oro_logfile = oro_logfile.
                gsub('%m', real_name).
                gsub('%p', pid.to_s)
            if working_directory
                oro_logfile = File.expand_path(oro_logfile, working_directory)
            end
            ENV['ORO_LOGFILE'] = oro_logfile
        else
            ENV['ORO_LOGFILE'] = "/dev/null"
        end

        if output
            STDERR.reopen(output)
            STDOUT.reopen(output)
        end

        if output_file_name && valgrind
            cmdline.unshift "--log-file=#{output_file_name}.valgrind"
        end

        if cmdline_wrapper
            cmdline = cmdline_wrapper_options + cmdline
            cmdline.unshift cmdline_wrapper
        end
        
        # Command line arguments have to be of type --<option>=<value>
        # or if <value> is nil a valueless option, i.e. --<option>
        if cmdline_args
            cmdline_args.each do |option, value|
                if value
                   if value.respond_to?(:to_ary)
                        value.each do |v|
                            cmdline.push "--#{option}=#{v}"
                        end
                   else
                       cmdline.push "--#{option}=#{value}"
                   end
                else
                    cmdline.push "--#{option}"
                end
            end
        end

        read.close
        write.fcntl(Fcntl::F_SETFD, 1)
        ::Process.setpgrp
        begin
            if working_directory
                Dir.chdir(working_directory)
            end
            exec(*cmdline)
        rescue Exception
            write.write("FAILED")
        end
    end
    Process.register(self)

    write.close
    if read.read == "FAILED"
        raise "cannot start #{name}"
    end

    if gdb
        Orocos.warn "process #{name} has been started under gdbserver, port=#{gdb_port}. The components will not be functional until you attach a GDB to the started server"
    end

    if wait
        timeout = if wait.kind_of?(Numeric)
                      wait
                  elsif wait
                      Float::INFINITY
                  end
        wait_running(timeout, name_service)
    end
end

# File lib/orocos/process.rb, line 1230
def wait_running(timeout = nil, name_service = Orocos::CORBA.name_service)
    Process.wait_running(self, timeout, name_service)
end