csd 0.0.15 → 0.0.16

data/lib/csd/application/minisip.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), 'default')
+Dir.glob(File.join(File.dirname(__FILE__), 'minisip', '*.rb')) { |file| require file }
+Dir.glob(File.join(File.dirname(__FILE__), 'minisip', 'unix', '*.rb')) { |file| require file }
+require 'ostruct'
+
+module CSD
+  module Application
+    module Minisip
+      class << self
+        
+        include CSD::Application::Default
+        
+        def instance
+          @instance ||= case Gem::Platform.local.os
+            when 'linux'
+              Unix::Base.new
+            else
+              Base.new
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/csd/application/minisip/about.yml

@@ -0,0 +1,14 @@
+human: MiniSIP
+description: An open-source SIP client for high-definition video conferencing.
+actions:
+  :public:
+    #- show: Shows further information about MiniSIP
+    - download: Downloads MiniSIP components (e.g. source code, configurations, docs,...)
+    #- install: Installs an application
+    #- check: Checks whether the environment dependencies for the application are satisfied
+  :developer:
+    - compile: Downloads and compiles MiniSIP from scratch
+    #- package: Packages a compiled application
+    #- publish: Submits a compiled package to the CSD package repository
+scopes:
+  --- {}

data/lib/csd/application/minisip/base.rb

@@ -0,0 +1,161 @@
+require File.join(File.dirname(__FILE__), '..', 'default', 'base')
+
+module CSD
+  module Application
+    module Minisip
+      class Base < CSD::Application::Base
+        
+        def compile!
+          define_root_path
+          define_paths
+          UI.separator
+          UI.info "This operation will download and compile MiniSIP.".green.bold
+          UI.separator
+          UI.info " Working directory:   ".green + Path.work.to_s.yellow
+          UI.info " Your Platform:       ".green + Gem::Platform.local.humanize.to_s.yellow
+          UI.info(" Application module:  ".green + self.class.name.to_s.yellow) if Options.developer
+          UI.separator
+          if Options.help
+            UI.info Options.helptext
+          else
+            unless Options.yes
+              exit unless UI.ask_yes_no("Continue?".red.bold, true)
+            end
+            compile_process
+          end
+          UI.separator
+        end
+
+        def compile_process
+          unless Options.only_fix_giomm
+            before_compile
+            Cmd.mkdir Path.work
+            make_hdviper if checkout_hdviper or Options.dry
+            checkout_minisip
+          end
+          fix_ubuntu_10_04 if Gem::Platform.local.kernel_version == '#36-Ubuntu SMP Thu Jun 3 22:02:19 UTC 2010' or Options.only_fix_giomm
+          unless Options.only_fix_giomm
+            make_minisip
+            after_compile
+          end
+        end
+                
+        def define_root_path
+          if Options.path
+            if File.directory?(Options.path)
+              Path.root = File.expand_path(Options.path)
+            else
+              raise Error::Options::PathNotFound, "The path `#{Options.path}´ doesn't exist."
+            end
+          else
+            Path.root = Options.temp ? Dir.mktmpdir : Dir.pwd
+          end
+        end
+
+        def define_paths
+          Path.work                      = Pathname.new(File.join(Path.root, 'minisip'))
+          Path.repository                = Pathname.new(File.join(Path.work, 'repository'))
+          Path.open_gl_display           = Pathname.new(File.join(Path.repository, 'libminisip', 'source', 'subsystem_media', 'video', 'display', 'OpenGLDisplay.cxx'))
+          Path.hdviper                   = Pathname.new(File.join(Path.work, 'hdviper'))
+          Path.hdviper_x264              = Pathname.new(File.join(Path.hdviper, 'x264'))
+          Path.hdviper_x264_test_x264api = Pathname.new(File.join(Path.hdviper_x264, 'test', 'x264API'))
+          Path.build                     = Pathname.new(File.join(Path.work, 'build'))
+          Path.build_bin                 = Pathname.new(File.join(Path.build, 'bin'))
+          Path.build_include             = Pathname.new(File.join(Path.build, 'include'))
+          Path.build_lib                 = Pathname.new(File.join(Path.build, 'lib'))
+          Path.build_lib_pkg_config      = Pathname.new(File.join(Path.build_lib, 'pkgconfig'))
+          Path.build_share               = Pathname.new(File.join(Path.build, 'share'))
+          Path.build_share_aclocal       = Pathname.new(File.join(Path.build_share, 'aclocal'))
+          Path.giomm_header              = Pathname.new(File.join('/', 'usr', 'bin', 'giomm', 'giomm.h'))
+        end
+        
+        def checkout_hdviper
+          if Path.hdviper.directory?
+            UI.warn "Skipping hdviper, because the directory already exists: #{Path.hdviper}"
+          else
+            if Path.hdviper.parent.writable? or Options.dry
+              UI.info "Downloading hdviper to: #{Path.hdviper}".green.bold
+              Cmd.run("git clone http://github.com/csd/libraries.git #{Path.hdviper}", :die_on_failure => true)
+              #Cmd.run("svn co --quiet svn://hdviper.org/hdviper/wp3/src #{Path.hdviper}")
+              return true
+            else
+              UI.error "Could not download hdviper (no permission): #{Path.hdviper}"
+            end
+          end
+        end
+        
+        def make_hdviper
+          Cmd.cd Path.hdviper_x264
+          Cmd.run('./configure')
+          Cmd.run('make')
+          Cmd.cd Path.hdviper_x264_test_x264api
+          Cmd.run('make')
+        end
+        
+        def checkout_minisip # TODO: Refactor because redudancy with checkout_hdviper
+          if Path.repository.directory?
+            UI.warn "Skipping repository download, because the directory already exists: #{Path.repository}"
+          else
+            if Path.repository.parent.writable? or Options.dry
+              UI.info "Downloading minisip repository to: #{Path.repository}".green.bold
+              Cmd.run("git clone http://github.com/csd/minisip.git #{Path.repository}", :die_on_failure => true)
+              # Fixing hard-coded stuff
+              Cmd.replace(Path.open_gl_display, '/home/erik', Path.build)
+            else
+              UI.error "Could not download minisip repository (no permission): #{Path.hdviper}"
+            end
+          end
+        end
+        
+        def fix_ubuntu_10_04
+          Path.new_giomm_header = File.join(Dir.mktmpdir, 'header.h')
+          Cmd.copy(Path.giomm_header, Path.new_giomm_header)
+          Cmd.replace(Path.new_giomm_header, '#include <giomm/socket.h>', "/* ----- AI COMMENTING OUT START ----- \n#include <giomm/socket.h>")
+          Cmd.replace(Path.new_giomm_header, '#include <giomm/srvtarget.h>', "#include <giomm/srvtarget.h>\n ----- AI COMMENTING OUT END ----- */")
+          Cmd.replace(Path.new_giomm_header, '#include <giomm/unixconnection.h>', "// #include <giomm/unixconnection.h>  // COMMENTED OUT BY AI")
+          Cmd.run("sudo cp #{Path.giomm_header} #{Path.giomm_header}.backup")
+          Cmd.run("sudo cp #{Path.new_giomm_header} #{Path.giomm_header}")
+        end
+        
+        def make_minisip
+          [Path.build, Path.build_include, Path.build_lib, Path.build_share, Path.build_share_aclocal].each { |target| Cmd.mkdir target }
+          ['libmutil', 'libmnetutil', 'libmcrypto', 'libmikey', 'libmsip', 'libmstun', 'libminisip', 'minisip'].each do |library|
+            directory = Pathname.new(File.join(Path.repository, library))
+            next if Options.only and !Options.only.include?(library)
+            if Cmd.cd(directory) or Options.dry
+              if Options.bootstrap
+                UI.info "Bootstrapping #{library}".green.bold
+                Cmd.run("./bootstrap -I #{Path.build_share_aclocal.enquote}", :die_on_failure => true)
+              end
+              if Options.configure
+                UI.info "Configuring #{library}".green.bold
+                individual_options = case library
+                  when 'libminisip'
+                    %Q{--enable-debug --enable-video --disable-mil --enable-decklink --enable-opengl --disable-sdl CPPFLAGS="-I#{Path.hdviper_x264_test_x264api} -I#{Path.hdviper_x264}" LDFLAGS="#{File.join(Path.hdviper_x264_test_x264api, 'libx264api.a')} #{File.join(Path.hdviper_x264, 'libtidx264.a')} -lpthread -lrt"}
+                    #%Q{--enable-debug --enable-video --disable-mil --disable-decklink --enable-opengl --disable-sdl CPPFLAGS="-I#{Path.hdviper_x264}" LDFLAGS="#{File.join(Path.hdviper_x264, 'libx264.a')} -lpthread -lrt"}
+                  when 'minisip'
+                    %Q{--enable-debug --enable-video --enable-textui --enable-opengl}
+                  else
+                    ''
+                end
+                Cmd.run(%Q{./configure #{individual_options} --prefix=#{Path.build.enquote} PKG_CONFIG_PATH=#{Path.build_lib_pkg_config.enquote} ACLOCAL_FLAGS=#{Path.build_share_aclocal} LD_LIBRARY_PATH=#{Path.build_lib.enquote} --silent}, :die_on_failure => true)
+              end
+              if Options.make
+                UI.info "Make #{library}".green.bold
+                Cmd.run("make", :die_on_failure => true)
+              end
+              if Options.make_install
+                maker_command = Options.make_dist ? 'dist' : 'install'
+                UI.info "Make #{maker_command} #{library}".green.bold
+                Cmd.run("make #{maker_command}", :die_on_failure => true)
+              end
+            else
+              UI.warn "Skipping minisip library #{library} because it not be found: #{directory}".green.bold
+            end
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/csd/application/minisip/error.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), '..', '..', 'error')
+
+module CSD
+  module Error
+  
+    module Options
+      class PathNotFound < CSDError; status_code(200); end
+    end
+    
+  end
+end

data/lib/csd/application/minisip/options/compile.rb

@@ -0,0 +1,59 @@
+# This file gets eval'ed by the global options parser in lib/csd/rb
+# TODO: There must be a nicer solution for this.
+
+self.temp = false
+opts.on("-t", "--temp",
+        "Use a subdirectory in the system's temporary directory",
+        "to download files and not the current directory") do |value|
+  self.temp = value
+end
+
+self.path = nil
+opts.on("--path [PATH]",
+        "Defines the working directory manually.",
+        "(This will override the --temp option)") do |value|
+  self.path = value
+end
+
+#self.owner = nil
+#opts.on("-o", "--owner [OWNER]","Specify OWNER:GROUP for this operation") do |value|
+#  if owner = value
+#    chmod = owner.split(':')
+#    self.owner = chmod.first
+#    self.group = chmod.last
+#  end
+#end
+
+self.apt_get = true
+opts.on("--no-apt-get","Don't run any apt-get commands") do |value|
+  self.apt_get = value
+end
+
+self.bootstrap = true
+opts.on("--no-bootstrap","Don't run any bootstrap commands") do |value|
+  self.bootstrap = value
+end
+
+self.configure = true
+opts.on("--no-configure","Don't run any configure commands") do |value|
+  self.configure = value
+end
+
+self.make = true
+opts.on("--no-make","Don't run any make commands") do |value|
+  self.make = value
+end
+
+self.make_install = true
+opts.on("--no-make-install","Don't run any make install commands") do |value|
+  self.make_install = value
+end
+
+self.make_dist = false
+opts.on("--make-dist","Use `make dist´ instead of `make install´") do |value|
+  self.make_dist = value
+end
+
+opts.on("--only libmcrypto,libmnetuli,etc.", Array, "Process only these libraries") do |list|
+  self.only = list
+end

data/lib/csd/{applications → application}/minisip/unix/base.rb

@@ -1,28 +1,28 @@
 require File.join(File.dirname(__FILE__), '..', 'base')
 
-module Csd
+module CSD
   module Application
     module Minisip
       module Unix
-        class Base < Csd::Application::Minisip::Base
+        class Base < CSD::Application::Minisip::Base
           
           # A list of apt-get packages that are required by this application. 
           #
-          DEBIAN_DEPENDENCIES = %w{ libssl-dev libglademm-2.4-dev libsdl-dev git-core subversion automake libtool libltdl3-dev build-essential libavcodec-dev libswscale-dev nasm yasm libasound2-dev libsdl-ttf2.0-dev }
+          DEBIAN_DEPENDENCIES = %w{ libssl-dev libglademm-2.4-dev libsdl-dev git-core subversion automake libtool libltdl3-dev build-essential libavcodec-dev libswscale-dev libasound2-dev libsdl-ttf2.0-dev nasm yasm ffmpeg }
           
-          def before_build
-            fix_aclocal_dirlist
-            install_aptitude_dependencies
+          def before_compile
+            #fix_aclocal_dirlist
+            install_aptitude_dependencies if Options.apt_get
           end
         
-          def after_build
+          def after_compile
             ldconfig_and_gtkgui
           end
 
           def install_aptitude_dependencies
             DEBIAN_DEPENDENCIES.each do |apt|
-              run_command("sudo apt-get --yes install #{apt}")
-            end if options.apt_get
+              Cmd.run("sudo apt-get --yes install #{apt}")
+            end
           end
         
           def fix_aclocal_dirlist
@@ -43,8 +43,7 @@ module Csd
           end
 
           def ldconfig_and_gtkgui
-            run_command("ldconfig /usr/local/lib/libminisip.so.0")
-            run_command("minisip_gtkgui")
+            Cmd.run(File.join(Path.build, "minisip_gtkgui"))
           end
         
         end

data/lib/csd/application/opensips/about.yml

@@ -0,0 +1,2 @@
+human: opensips
+description: An open-source SIP server.

data/lib/csd/applications.rb

@@ -0,0 +1,55 @@
+require 'ostruct'
+require 'active_support/inflector'
+require 'active_support/core_ext/string/inflections'
+
+module CSD
+  
+  # A convenience wrapper to get information about the available applications
+  #
+  class Applications
+
+    # Returns nil if application could not be found
+    #
+    def self.find(app_name)
+      begin
+        require File.join(Path.applications, app_name.to_s)
+        ActiveSupport::Inflector.constantize "CSD::Application::#{app_name.camelize}"
+      rescue LoadError
+        UI.debug "The Application `#{app_name}´ could not be loaded properly."
+        nil
+      end
+    end
+
+    def self.all(&block)
+      result = []
+      Dir.directories(Path.applications) do |dir|
+        next if dir == 'default'
+        if app = find(dir)
+          block_given? ? yield(app) : result << app
+        end
+      end
+      result
+    end
+
+    def self.valid?(name)
+      list.include?(name)
+    end
+    
+    # This method identifies the desired application and initializes it in to +@@current+.
+    # It is meant to be very robust, we expect the application to be any one of the first three arguments.
+    #
+    def self.current
+      @@current ||= begin
+        Applications.find(ARGV.first) || Applications.find(ARGV.second) || Applications.find(ARGV.third)
+      end
+    end
+    
+    # Forces a reload of the current application. This method is useful for functional tests.
+    #
+    def self.current!
+      @@current = false
+      current
+    end
+    
+  end
+end

data/lib/csd/commands.rb

@@ -1,10 +1,10 @@
 require 'pathname'
 require 'ostruct'
-require 'active_support'
 
-module Csd
-  # This module contains wrapper methods for standard file system commands. They are meant to be
+module CSD
+  # This module contains wrapper methods for standard file system operations. They are meant to be
   # a little bit more robust (e.g. raising no exceptions) and return elaborate feedback on their operation.
+  # All of these methods, except for the +run+ method, are platform independent.
   #
   module Commands
     
@@ -54,20 +54,20 @@ module Csd
       target = target.pathnamify
       result = CommandResult.new
       if target.directory?
-        # Don't say anything if the directory already exists
+        # Don't do anything if the directory already exists
         result.already_existed = true
       else
         begin
-          say "Creating directory: #{target}".cyan unless options.quiet
+          UI.info "Creating directory: #{target}".cyan
           # Try to create the directory
-          target.mkpath unless options.dry
+          target.mkpath unless (Options.dry or Options.reveal)
         rescue Errno::EACCES => e
-           say "Cannot create directory (no permission): #{target}".red unless options.quiet
+           UI.error "Cannot create directory (no permission): #{target}"
            return result
         end
       end
-      result.success  = (target.directory? or options.dry)
-      result.writable = (target.writable? or options.dry)
+      result.success  = (target.directory? or Options.reveal)
+      result.writable = (target.writable? or Options.reveal)
       result
     end
     
@@ -82,13 +82,55 @@ module Csd
     def cd(target)
       target = target.pathnamify
       result = CommandResult.new
-      if target.directory? or options.dry
-        say "cd #{target}".yellow
-        Dir.chdir(target)
+      if target.directory? or Options.reveal
+        UI.info "cd #{target}".yellow
+        if Options.reveal
+          @pwd = target.to_s
+        else
+          Dir.chdir(target)
+        end
       elsif target.exist?
-        say "Cannot change to directory because it exists but is not a directory: #{target}".red
+        UI.error "Cannot change to directory because it exists but is not a directory: #{target}".red
+      end
+      result.success = (target.current_path? or Options.reveal)
+      result
+    end
+    
+    # Copies one or several files to the destination
+    #
+    def copy(src, dest)
+      FileUtils.cp(src, dest)
+    end
+    
+    # This returns the current pwd. However, it will return a fake result if we are in reveal-commands-mode.
+    #
+    def pwd
+      if Options.reveal
+        @pwd ||= Dir.pwd
+      else
+        Dir.pwd
+      end
+    end
+    
+    # Replaces all occurences of a pattern in a file
+    #
+    # ==== Returns
+    #
+    # This method returns a CommandResult object with the following values:
+    #
+    # [+success?+] +true+ if the replacement was successful, +nil+ if not.
+    #
+    def replace(filepath, pattern, substitution)
+      result = CommandResult.new
+      begin
+        UI.info "Modifying contents of `#{filepath}´ as follows:".blue
+        UI.info "  (Replacing all occurences of `#{pattern}´ with `#{substitution}´)".blue
+        new_file_content = File.read(filepath).gsub(pattern, substitution)
+        File.open(filepath, 'w+') { |file| file << new_file_content }
+      rescue Errno::ENOENT => e
+        result.success = false
       end
-      result.success = (target.current_path? or options.dry)
+      result.success = true
       result
     end
     
@@ -96,7 +138,7 @@ module Csd
     #
     # ==== Returns
     #
-    # The command's output as an +Array+. Note that the exit code can be accessed via the global variable <tt>$?</tt>
+    # The command's output as a +String+ (with newline delimiters). Note that the exit code can be accessed via the global variable <tt>$?</tt>
     #
     # ==== Options
     #
@@ -104,68 +146,49 @@ module Csd
     #
     # [+:exit_on_failure+] If the exit code of the command was not 0, exit the CSD application.
     #
-    #
-    def sh(cmd, params={})
-      default_params = { :exit_on_failure => true }
+    def run(cmd, params={})
+      default_params = { :die_on_failure => true, :silent => false }
       params = default_params.merge(params)
-      say "Running command in #{Dir.pwd}".yellow unless options.silent
-      say cmd.cyan
-      ret = ''
-      unless options.dry
-        IO.popen(cmd) do |stdout|
-          stdout.each do |line|
-            say "       #{line}" if options.verbose
-            ret << line
-          end
-        end
+      unless params[:silent]
+        UI.info "Running command in #{pwd}".yellow
+        UI.info cmd.cyan
       end
-      exit_if_last_command_had_errors if params[:exit_on_failure]
-      ret
-    end
-    
-    
-    def test_command(*args)
-      say "Testing command for success: #{args.join(' ')}".yellow
-      system(*args)
-    end
-    
-    def run_command(cmd, params={})
-      default_params = { :exit_on_failure => true }
-      params = default_params.merge(params)
-      say "Running command in #{Dir.pwd}".yellow unless options.quiet
-      say cmd.cyan
+      return '' if Options.reveal
       ret = ''
-      unless options.dry
-        IO.popen(cmd) do |stdout|
-          stdout.each do |line|
-            say "       #{line}"
-            ret << line
-          end
+      IO.popen(cmd) do |stdout|
+        stdout.each do |line|
+          UI.info "       #{line}" unless params[:silent]
+          ret << line
         end
       end
-      exit_if_last_command_had_errors if params[:exit_on_failure]
+      die_if_last_command_had_errors if params[:exit_on_failure]
       ret
     end
     
-    def exit_if_last_command_had_errors
-      unless $?.try(:success?) or options.dry
-        say "The last command was unsuccessful.".red unless options.quiet
-        exit
-      end
+    def die_if_last_command_had_errors
+      UI.die "The last command was unsuccessful." unless $?.try(:success?)
     end
+  
+  end
+  
+  # Having a class to include all command modules
+  #
+  class CommandsInstance
+    include Commands
+  end
+  
+  # Wrapping the CommandsInstance class
+  #
+  class Cmd
+    COMMANDS = %w{ mkdir cd run replace }
     
-    
-    def say(something='')
-    end
-
-    def log(msg="")
-      say msg.yellow unless options.silent
+    def self.instance
+      @@instance ||= CommandsInstance.new
     end
     
-    # Dummy to be overwritten by real options
-    def options
-      OpenStruct.new
+    def self.method_missing(meth, *args, &block)
+      COMMANDS.include?(meth.to_s) ? instance.send(meth, *args, &block) : super
     end
-  
   end
+  
 end