taskjuggler 0.0.2

data/lib/BatchProcessor.rb

@@ -0,0 +1,209 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Project.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'thread'
+require 'monitor'
+
+class TaskJuggler
+
+  # The JobInfo class is just a storage container for some batch job realted
+  # pieces of information. It contains things like a job id, the process id,
+  # the stdout data and the like.
+  class JobInfo
+
+    attr_reader :jobId, :block, :tag
+    attr_accessor :pid, :retVal, :stdoutP, :stdoutC, :stdout,
+                  :stderrP, :stderrC, :stderr
+
+    def initialize(jobId, block, tag)
+      # The job id. A unique number that is used by the BatchProcessor objects
+      # to indentify jobs.
+      @jobId = jobId
+      # This the the block of code to be run as external process.
+      @block = block
+      # The tag can really be anything that the user of BatchProcessor needs
+      # to uniquely identify the job.
+      @tag = tag
+      # The pipe to transfer stdout data from the child to the parent.
+      @stdoutP, @stdoutC = IO.pipe
+      # The stdout output of the child
+      @stdout = ''
+      # The pipe to transfer stderr data from the child to the parent.
+      @stderrP, @stderrC = IO.pipe
+      # The stderr output of the child
+      @stderr = ''
+    end
+
+  end
+
+  # The BatchProcessor class can be used to run code blocks of the program as
+  # a separate process. Mulitple pieces of code can be submitted to be
+  # executed in parallel. The number of CPU cores to use is limited at object
+  # creation time. The submitted jobs will be queued and scheduled to the
+  # given number of CPUs. The usage model is simple. Create an BatchProcessor
+  # object. use BatchProcessor#queue to submit all the jobs and then use
+  # BatchProcessor#wait to wait for completion and to process the results.
+  class BatchProcessor
+
+    # Create a BatchProcessor object. +maxCpuCores+ limits the number of
+    # simultaneously spawned processes.
+    def initialize(maxCpuCores)
+      @maxCpuCores = maxCpuCores
+      # The job queue.
+      @queue = Queue.new
+      # A semaphore to guard accesses to shared data structures.`
+      @lock = Monitor.new
+      # A hash that maps process ids to JobInfo objects.
+      @jobs = { }
+      # Counts the number of pending processes.
+      @pendingJobs = 0
+      # An Array that holds all the IO objects to receive data from.
+      @pipes = []
+      # A hash that maps IO objects to JobInfo objects
+      @pipeToJob = {}
+      # This global flag is set to true to signal the threads to terminate.
+      @terminate = false
+      # Sleep time of the threads when no data is pending.
+      @timeout = 0.05
+
+      Thread.abort_on_exception = true
+      # The JobInfo objects in the @queue are processed by the pusher thread.
+      # It forkes off processes to execute the code block associated with the
+      # JobInfo.
+      @pusher = Thread.new { pusher }
+      # The popper thread waits for terminated childs and picks up the
+      # results.
+      @popper = Thread.new { popper }
+      # The grabber thread collects $stdout and $stderr data from each child
+      # process and stores them in the corresponding JobInfo.
+      @grabber = Thread.new { grabber }
+    end
+
+    # Add a new job the job queue. +tag+ is some data that the caller can use
+    # to identify the job upon completion. +block+ is a Ruby code block to be
+    # executed in a separate process.
+    def queue(tag = nil, &block)
+      # Create a new JobInfo object for the job and push it to the @queue.
+      jobInfo = JobInfo.new(@queue.length, block, tag)
+      @queue.push(jobInfo)
+      @lock.synchronize do
+        # Add the receiver end of the pipe to the @pipes Array.
+        @pipes << jobInfo.stdoutP
+        # Map the pipe end to this JobInfo object.
+        @pipeToJob[jobInfo.stdoutP] = jobInfo
+        # Same for $stderr.
+        @pipes << jobInfo.stderrP
+        @pipeToJob[jobInfo.stderrP] = jobInfo
+      end
+    end
+
+    # Wait for all jobs to complete. The code block will get the JobInfo
+    # objects for each job to pick up the results.
+    def wait
+      while !@queue.empty? || @pendingJobs > 0 do
+        sleep(@timeout)
+      end
+
+      # Signal threads to stop
+      @terminate = true
+      # Wait for treads to finish
+      @pusher.join
+      @popper.join
+      @grabber.join
+
+      # Pass the results of the jobs to the caller.
+      @jobs.each_value { |job| yield(job) }
+    end
+
+    private
+
+    # This function runs in a separate thread to pop JobInfo items from the
+    # @queue and create child processes for them.
+    def pusher
+      # Run until the terminate flag is set.
+      until @terminate
+        if @queue.empty? || @pendingJobs >= @maxCpuCores
+          # We have no jobs in the @queue or all CPU cores in use already.
+          sleep(@timeout)
+        else
+          # Get a new job from the @queue
+          job = @queue.pop
+          job.pid = fork do
+            # This is the child process now. Connect $stdout and $stderr to
+            # the pipes.
+            $stdout.reopen(job.stdoutC)
+            job.stdoutC.close
+            $stderr.reopen(job.stderrC)
+            job.stderrC.close
+            # Call the Ruby code block
+            job.block.call
+          end
+          @lock.synchronize do
+            # Save the process ID in the PID to JobInfo hash.
+            @jobs[job.pid] = job
+            # Increase the jobs-in-flight counter.
+            @pendingJobs += 1
+          end
+        end
+      end
+    end
+
+    # This function runs in a separate thread to wait for completed jobs. It
+    # waits for the process completion and stores the result in the
+    # corresponding JobInfo object.
+    def popper
+      until @terminate
+        if @pendingJobs == 0
+          # No pending jobs, wait a bit.
+          sleep(@timeout)
+        else
+          # Wait for the next job to complete.
+          pid, retVal = Process.wait2
+          @lock.synchronize do
+            # Get the JobInfo object that corresponds to the process ID.
+            job = @jobs[pid]
+            raise "Unknown job" if pid.nil?
+            # Save the return value.
+            job.retVal = retVal
+            # We have one less job to worry about.
+            @pendingJobs -= 1
+          end
+        end
+      end
+    end
+
+    # This function runs in a separate thread to pick up the $stdout and
+    # $stderr outputs of the child processes. It stores them in the JobInfo
+    # object that corresponds to each child process.
+    def grabber
+      until @terminate
+        # Wait for output in any of the pipes or a timeout.
+        if (res = select(@pipes, nil, nil, @timeout))
+          # We have output data from at least one child. Check which pipe
+          # actually triggered the select.
+          res[0].each do |pipe|
+            # Find the corresponding JobInfo object.
+            job = @pipeToJob[pipe]
+            # Store the output.
+            if pipe == job.stdoutP
+              job.stdout << pipe.getc
+            else
+              job.stderr << pipe.getc
+            end
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/lib/Booking.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Booking.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+class TaskJuggler
+
+  class Booking
+
+    attr_reader :resource, :task, :intervals
+    attr_accessor :sourceFileInfo, :overtime, :sloppy
+
+    def initialize(resource, task, intervals)
+      @resource = resource
+      @task = task
+      @intervals = intervals
+      @sourceFileInfo = nil
+      @overtime = 0
+      @sloppy = 0
+    end
+
+    def to_s
+      out = "#{@resource.fullId} "
+      first = true
+      @intervals.each do |iv|
+        if first
+          first = false
+        else
+          out += ", "
+        end
+        out += "#{iv.start} + #{(iv.end - iv.start) / 3600}h"
+      end
+    end
+
+    def to_tjp
+      out = "#{@resource.fullId} "
+      first = true
+      @intervals.each do |iv|
+        if first
+          first = false
+        else
+          out += ",\n"
+        end
+        out += "#{iv.start} + #{(iv.end - iv.start) / 3600}h"
+      end
+      out += ' { overtime 2 }'
+    end
+
+  end
+
+end
+

data/lib/Charge.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = Charge.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'TjTime'
+
+class TaskJuggler
+
+  # This class describes a one-time or per time charge that can be assiciated
+  # with a Task. The charge can take effect either on starting the task,
+  # finishing it, or per time interval.
+  class Charge
+
+    # Create a new Charge object. _amount_ is either the one-time charge or the
+    # per-day-rate. _task_ is the Task that owns this charge. _scenarioIdx_ is
+    # the index of the scenario this Charge belongs to.
+    def initialize(amount, mode, task, scenarioIdx)
+      @amount = amount
+      unless [ :onStart, :onEnd, :perDiem ].include?(mode)
+        raise "Unsupported mode #{mode}"
+      end
+      @mode = mode
+      @task = task
+      @scenarioIdx = scenarioIdx
+    end
+
+    # Compute the total charge for the Interval described by _period_.
+    def turnover(period)
+      case @mode
+      when :onStart
+        return period.contains?(@task['start', @scenarioIdx]) ? @amount : 0.0
+      when :onEnd
+        return period.contains?(@task['end', @scenarioIdx]) ? @amount : 0.0
+      else
+        iv = period.intersection(Interval.new(@task['start', @scenarioIdx],
+                                              @task['end', @scenarioIdx]))
+        if iv
+          return (iv.duration / (60 * 60 * 24)) * @amount
+        else
+          return 0.0
+        end
+      end
+    end
+
+    # Dump object in human readable form.
+    def to_s
+      case @mode
+      when :onStart
+        mode = 'on start'
+      when :onEnd
+        mode = 'on end'
+      when :perDiem
+        mode = 'per day'
+      else
+        mode = 'unknown'
+      end
+      "#{@amount} #{mode}"
+    end
+
+  end
+
+end
+

data/lib/ChargeSet.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby -w
+# encoding: UTF-8
+#
+# = ChargeSet.rb -- The TaskJuggler III Project Management Software
+#
+# Copyright (c) 2006, 2007, 2008, 2009 by Chris Schlaeger <cs@kde.org>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of version 2 of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+
+require 'TjException'
+
+class TaskJuggler
+
+  # A charge set describes how a given amount is distributed over a set of
+  # accounts. It stores the percentage share for each account. The accumulated
+  # percentages must always be 100% for a valid charge set. For consistency
+  # reasons, accounts must always be leaf accounts of the same top-level
+  # account. Percentage values must range from 0.0 to 1.0.
+  class ChargeSet
+
+    attr_reader :master
+
+    # Create a new ChargeSet object.
+    def initialize
+      @set = {}
+      @master = nil
+    end
+
+    # Add a new account to the set. Accounts and share rates must meet a number
+    # of requirements. This method does some error checking and raises a
+    # TjException in case of problems. It cannot check everything. Accounts can
+    # later be turned into group accounts or the total share sum may not be
+    # 100%. This needs to be checked at a later stage. Accounts may have a share
+    # of nil. This will be set in ChargeSet#complete later.
+    def addAccount(account, share)
+      unless account.leaf?
+        raise TjException.new,
+          "Account #{account.fullId} is a group account and cannot be used " +
+          "in a chargeset."
+      end
+      if @set.include?(account)
+        raise TjException.new,
+          "Account #{account.fullId} is already a member of the charge set."
+      end
+      if @master.nil?
+        @master = account.root
+      elsif @master != account.root
+        raise TjException.new,
+          "All members of this charge set must belong to the " +
+          "#{@master.fullId} account. #{account.fullId} belongs to " +
+          "#{account.root.fullId}."
+      end
+      if account.container?
+        raise TjException.new,
+          "#{account.fullId} is a group account. Only leaf accounts are " +
+          "allowed for a charge set."
+      end
+      if share && (share < 0.0 || share > 1.0)
+        raise TjException.new, "Charge set shares must be between 0 and 100%"
+      end
+      @set[account] = share
+    end
+
+    def each
+      @set.each do |account, share|
+        yield account, share
+      end
+    end
+
+    # Check for accounts that don't have a share yet and distribute the
+    # remainder to 100% evenly accross them.
+    def complete
+      # Calculate the current total share.
+      totalPercent = 0.0
+      undefined = 0
+      @set.each_value do |share|
+        if share
+          totalPercent += share
+        else
+          undefined += 1
+        end
+      end
+      # Must be less than 100%.
+      if totalPercent > 1.0
+        raise TjException.new,
+          "Total share of this set (#{totalPercent * 100}%) excedes 100%."
+      end
+      if undefined > 0
+        commonShare = (1.0 - totalPercent) / undefined
+        if commonShare <= 0
+          raise TjException.new,
+            "Total share is 100% but #{undefined} account(s) still exist."
+        end
+        @set.each do |account, share|
+          if share.nil?
+            @set[account] = commonShare
+          end
+        end
+      elsif totalPercent != 1.0
+        raise TjException.new,
+          "Total share of this set is #{totalPercent * 100} instead of 100%."
+      end
+    end
+
+    # Return the share percentage for a given Account _account_.
+    def share(account)
+      @set[account]
+    end
+
+    # Return the set as comma separated list of account ID + share pairs.
+    def to_s
+      str = '('
+      @set.each do |account, share|
+        str += ', ' unless str == '('
+        str += "#{account.fullId} #{share * 100}%"
+      end
+      str += ')'
+    end
+
+  end
+
+end
+