sakai-info 0.1.0

data/lib/sakai-info/cli.rb

@@ -0,0 +1,35 @@
+# sakai-info/cli.rb
+#  - sakai-info command line tool support
+#
+# Created 2012-02-19 daveadams@gmail.com
+# Last updated 2012-02-19 daveadams@gmail.com
+#
+# https://github.com/daveadams/sakai-info
+#
+# This software is public domain.
+#
+
+require 'sakai-info/cli/help'
+
+module SakaiInfo
+  class CLI
+    def self.validate_config
+      return true if Configuration.configured?
+
+      begin
+        Configuration.load_config
+        return true
+      rescue NoConfigFoundException
+        STDERR.puts "ERROR: No configuration file was found at #{Configuration::DEFAULT_CONFIG_FILE}"
+        return false
+      rescue InvalidConfigException => e
+        STDERR.puts "ERROR: Configuration was invalid:"
+        e.message.each_line do |line|
+          STDERR.puts "  #{line.chomp}"
+        end
+        return false
+      end
+    end
+  end
+end
+

data/lib/sakai-info/cli/help.rb

@@ -0,0 +1,103 @@
+# sakai-info/cli/help.rb
+#  - sakai-info command line help
+#
+# Created 2012-02-19 daveadams@gmail.com
+# Last updated 2012-02-19 daveadams@gmail.com
+#
+# https://github.com/daveadams/sakai-info
+#
+# This software is public domain.
+#
+
+module SakaiInfo
+  class CLI
+    class Help
+      STRINGS = {
+        :default => <<EOF,
+sakai-info #{VERSION}
+
+Object commands:
+  user         Print information about a user or users
+  site         Print information about a site or sites
+
+Misc commands:
+  validate     Validates configuration
+  help         Prints general help
+  version      Prints version
+
+Type 'sakai-info help <command>' for help on a specific command.
+EOF
+
+        "help" => <<EOF,
+sakai-info help
+
+  Prints usage information for other sakai-info commands, or without an
+  argument it prints a list of possible commands.
+
+  Usage: sakai-info help [<command>]
+EOF
+
+        "version" => <<EOF,
+sakai-info version
+
+  Prints the current version of sakai-info.
+
+  Usage: sakai-info version
+EOF
+
+        "validate" => <<EOF,
+sakai-info validate
+
+  Reads and validates the current configuration format. To test the actual
+  database connections, use 'sakai-info test'.
+
+  Usage: sakai-info validate
+EOF
+
+        "test" => <<EOF,
+sakai-info test
+
+  [NOT YET IMPLEMENTED]
+
+  Reads configuration and tests connecting to each database specified, or with
+  an argument, it will test only the named instance.
+
+  Usage: sakai-info test [<instance>]
+EOF
+
+        "user" => <<EOF,
+sakai-info user
+
+  In this release, this command prints the total number of records in the
+  SAKAI_USER table. In future releases, subcommands will be available to
+  perform more tasks.
+
+  Usage: sakai-info user [<subcommand>]
+EOF
+
+        "site" => <<EOF,
+sakai-info site
+
+  In this release, this command prints the total number of records in the
+  SAKAI_SITE table. In future releases, subcommands will be available to
+  perform more tasks.
+
+  Usage: sakai-info site [<subcommand>]
+EOF
+      }
+
+      def self.help(topic = :default, io = STDOUT)
+        topic ||= :default
+        if STRINGS.has_key? topic
+          io.puts STRINGS[topic]
+        else
+          STDERR.puts "ERROR: help topic '#{topic}' was unrecognized"
+          STDERR.puts
+          CLI.help(:default, STDERR)
+          exit 1
+        end
+      end
+    end
+  end
+end
+

data/lib/sakai-info/configuration.rb

@@ -0,0 +1,288 @@
+# sakai-info/configuration.rb
+#   SakaiInfo::Configuration library
+#
+# Created 2012-02-15 daveadams@gmail.com
+# Last updated 2012-02-19 daveadams@gmail.com
+#
+# https://github.com/daveadams/sakai-info
+#
+# This software is public domain.
+#
+
+module SakaiInfo
+  class NoConfigFoundException < SakaiException; end
+  class AlreadyConfiguredException < SakaiException; end
+  class InvalidInstanceNameException < SakaiException; end
+  class InvalidConfigException < SakaiException; end
+  class UnsupportedConfigException < InvalidConfigException; end
+  class MultipleConfigException < InvalidConfigException
+    def initialize
+      @exceptions = []
+    end
+
+    def add(instance_name, exception)
+      @exceptions << [instance_name, exception]
+    end
+
+    def count
+      @exceptions.length
+    end
+
+    def message
+      "Multiple config exceptions were found:\n  " +
+        @exceptions.collect{ |e| "#{e[0]}: #{e[1].message}" }.join("\n  ")
+    end
+  end
+
+  # config format assumptions:
+  #   a YAML string containing one of the following options:
+  #     - a single database connection spec
+  #     - eg:
+  #         ---
+  #         dbtype: oracle
+  #         dbsid: PROD
+  #         username: sakai
+  #         password: Sekrit1
+  #   OR:
+  #     - an "instances" key containing a hash of named connection specs
+  #     - with a "default" key naming the spec to use if none is specified
+  #     - eg:
+  #         ---
+  #         default: production
+  #         instances:
+  #           production:
+  #             dbtype: oracle
+  #             service: PROD
+  #             username: sakai
+  #             password: prodpass
+  #           test:
+  #             dbtype: oracle
+  #             service: TEST
+  #             host: testdb.host
+  #             port: 1521
+  #             username: sakai
+  #             password: testpass
+  #           dev:
+  #             dbtype: mysql
+  #             host: dbserver.hostname.int
+  #             port: 3306
+  #             username: sakai
+  #             password: ironchef
+  #             dbname: sakaidev
+  #           localdev:
+  #             dbtype: mysql
+  #             host: localhost
+  #             port: 3306
+  #             username: sakai
+  #             password: ironchef
+  #             dbname: sakailocal
+  #
+  #
+  # NOTES:
+  #  - Oracle connections should use either an alias defined in the
+  #    driver's tnsnames.ora file, or specify the host and port as the
+  #    test instance example above does
+  #
+  class Configuration
+    @@config = nil
+
+    # validate just a single database connection configuration hash
+    def self.validate_single_connection_config(config)
+      if config.nil?
+        raise InvalidConfigException.new("The config provided was nil")
+      end
+
+      if not config.is_a? Hash
+        raise InvalidConfigException.new("The config provided must be a Hash")
+      end
+
+      # we have to have a dbtype value or we can't validate
+      if config["dbtype"].nil?
+        raise InvalidConfigException.new("The config does not specify 'dbtype'")
+      end
+
+      # force lowercase to simplify comparisons
+      dbtype = config["dbtype"].downcase
+
+      if not %w(oracle mysql).include? dbtype
+        raise UnsupportedConfigException.new("Database type '#{dbtype}' is not supported.")
+      end
+
+      # now check per-dbtype requirements
+      if dbtype == "oracle"
+        %w(service username password).each do |required_key|
+          if config[required_key].nil? or config[required_key] == ""
+            raise InvalidConfigException.new("Oracle config requires values for 'service', 'username', and 'password'.")
+          end
+        end
+      elsif dbtype == "mysql"
+        %w(host username password dbname).each do |required_key|
+          if config[required_key].nil? or config[required_key] == ""
+            raise InvalidConfigException.new("MySQL config requires values for 'host', 'username', 'password', and 'dbname'.")
+          end
+        end
+      else
+        # we should never have made it here
+        raise UnsupportedConfigException.new("Database type '#{dbtype}' is not supported.")
+      end
+
+      # for both types, 'port' is optional but if it exists it must be a valid TCP port
+      if not config["port"].nil?
+        begin
+          port = config["port"].to_i
+          if port < 1 or port > 65535
+            raise
+          end
+        rescue
+          raise InvalidConfigException.new("Config value 'port' must be a valid TCP port number.")
+        end
+      end
+
+      # if we made it here the config is complete and well-formed
+      return true
+    end
+
+    # validate that configuration is complete and well-formed
+    def self.validate_config(config)
+      if config.nil?
+        raise InvalidConfigException.new("The config provided was nil")
+      end
+
+      if not config.is_a? Hash
+        raise InvalidConfigException.new("The config provided must be a Hash")
+      end
+
+      # if 'dbtype' exists, it will be a single database configuration
+      if config["dbtype"]
+        self.validate_single_connection_config(config)
+      else
+        # otherwise both 'default' and 'instances' keys are required
+        if config.keys.sort != ["default","instances"]
+          raise InvalidConfigException.new("The config must specify either 'dbtype' or both 'default' and 'instances'.")
+        end
+
+        # enforce types on the values of 'default' and 'instances'
+        if not config["default"].is_a? String
+          raise InvalidConfigException.new("The value of 'default' must be a String.")
+        end
+        if not config["instances"].is_a? Hash
+          raise InvalidConfigException.new("The value of 'instances' must be a Hash.")
+        end
+
+        # 'default' must be a string pointing to one of the 'instances' keys
+        if not config["instances"].keys.include? config["default"]
+          raise InvalidConfigException.new("The default instance '#{config["default"]}' was not among the instance names given: #{config["instances"].keys.inspect}")
+        end
+
+        # check the validity of each instance, collecting exceptions as we go
+        multi_exceptions = nil
+        config["instances"].keys.each do |instance_name|
+          begin
+            self.validate_single_connection_config(config["instances"][instance_name])
+          rescue InvalidConfigException => e
+            # create the object if it doesn't already exist
+            multi_exceptions ||= MultipleConfigException.new
+
+            # add this exception to the list
+            multi_exceptions.add(instance_name, e)
+          end
+          # continue the loop no matter what
+        end
+
+        # if this object was created, the exception needs to be raised
+        if not multi_exceptions.nil?
+          raise multi_exceptions
+        end
+      end
+
+      # if we've made it this far, the configuration must be fine
+      return true
+    end
+
+    def initialize(config)
+      begin
+        if config.is_a? Hash
+          @config = config
+        elsif config.is_a? String and File.exist?(config)
+          # try to parse as a filename first
+          if File.exist?(config)
+            @config = YAML::load_file(config)
+          end
+        else
+          # otherwise try to parse it generically
+          @config = YAML::load(config)
+        end
+      rescue Exception => e
+        raise InvalidConfigException.new("Unable to parse configuration: #{e}")
+      end
+
+      # check that the configuration specified is well formed
+      if not Configuration.validate_config(@config)
+        raise InvalidConfigException.new("Config provided is either incomplete or poorly formed.")
+      end
+
+      # create instance objects
+      @instances = {}
+      if not @config["instances"].nil?
+        @config["instances"].keys.each do |instance_name|
+          @instances[instance_name] = Instance.create(@config["instances"][instance_name])
+          if instance_name == @config["default"]
+            @instances[:default] = @instances[instance_name]
+          end
+        end
+      else
+        @instances[:default] = Instance.create(@config)
+      end
+    end
+
+    # instance accessibility
+    def get_instance(instance_name)
+      @instances[instance_name] or raise InvalidInstanceNameException
+    end
+
+    def default_instance
+      @instances[:default]
+    end
+
+    DEFAULT_CONFIG_FILE = File.expand_path("~/.sakai-info")
+    # check to see if configuration file exists
+    # by default ~/.sakai-info
+    def self.config_file_path
+      if File.readable? DEFAULT_CONFIG_FILE
+        DEFAULT_CONFIG_FILE
+      else
+        nil
+      end
+    end
+
+    # are we already configured?
+    def self.configured?
+      not @@config.nil?
+    end
+
+    # load configuration as a class variable (and return it as well)
+    def self.load_config(alternate_config_file = nil)
+      if Configuration.configured?
+        raise AlreadyConfiguredException
+      end
+
+      unless(config_file = alternate_config_file || Configuration.config_file_path)
+        raise NoConfigFoundException
+      end
+
+      @@config = Configuration.new(config_file)
+    end
+
+    # return specified database connection configuration
+    def self.get_instance(instance_name = nil)
+      Configuration.load_config unless Configuration.configured?
+
+      if instance_name.nil?
+        @@config.default_instance
+      else
+        @@config.get_instance(instance_name)
+      end
+    end
+  end
+end
+

data/lib/sakai-info/content.rb

@@ -0,0 +1,300 @@
+# sakai-info/content.rb
+#   SakaiInfo::Content library
+#
+# Created 2012-02-17 daveadams@gmail.com
+# Last updated 2012-02-18 daveadams@gmail.com
+#
+# https://github.com/daveadams/sakai-info
+#
+# This software is public domain.
+#
+
+module SakaiInfo
+  class Content < SakaiObject
+    attr_reader :parent_id
+
+    def self.find(id)
+      begin
+        ContentResource.find(id)
+      rescue ObjectNotFoundException
+        begin
+          ContentCollection.find(id)
+        rescue ObjectNotFoundException
+          if not id.match(/\/$/)
+            ContentCollection.find(id + "/")
+          else
+            raise ObjectNotFoundException.new(Content, id)
+          end
+        end
+      end
+    end
+
+    def parent
+      if @parent_id.nil?
+        nil
+      else
+        @parent ||= ContentCollection.find(@parent_id)
+      end
+    end
+
+    def binary
+      if @binary.nil?
+        DB.connect.exec("select binary_entity from #{@table_name} " +
+                        "where #{@id_column} = :id", id) do |row|
+          @binary = row[0].read
+        end
+      end
+      @binary
+    end
+
+    def size_on_disk
+      0
+    end
+
+    def default_serialization
+      {
+        "id" => self.id,
+        "parent" => self.parent_id,
+        "size_on_disk" => self.size_on_disk
+      }
+    end
+
+    def summary_serialization
+      {
+        "id" => self.id,
+        "parent" => self.parent_id,
+        "size_on_disk" => self.size_on_disk
+      }
+    end
+
+    def realm
+      if @realm_is_nil
+        nil
+      else
+        begin
+          @realm ||= AuthzRealm.find_by_name("/content#{@id}")
+        rescue AuthzRealmNotFoundException
+          @realm_is_nil = true
+          nil
+        end
+      end
+    end
+
+    def effective_realm
+      self.realm || (parent.nil? ? nil : parent.effective_realm)
+    end
+  end
+
+  class ContentResource < Content
+    attr_reader :file_path, :uuid, :context, :resource_type_id
+
+    def initialize(id, parent_id, file_path, uuid, file_size, context, resource_type_id)
+      @id = id
+      @parent_id = parent_id
+      @file_path = File.join(Instance.content_base_directory, file_path)
+      @uuid = uuid
+      @file_size = file_size
+      @context = context
+      @resource_type_id = resource_type_id
+
+      @table_name = "content_resource"
+      @id_column = "resource_id"
+    end
+
+    @@cache = {}
+    def self.find(id)
+      if @@cache[id].nil?
+        DB.connect.exec("select resource_id, in_collection, file_path, " +
+                        "resource_uuid, file_size, context, resource_type_id " +
+                        "from content_resource " +
+                        "where resource_id=:id", id) do |row|
+          @@cache[id] = ContentResource.new(row[0], row[1], row[2], row[3], row[4].to_i, row[5], row[6])
+        end
+        if @@cache[id].nil?
+          raise ObjectNotFoundException.new(ContentResource, id)
+        end
+      end
+      @@cache[id]
+    end
+
+    def size_on_disk
+      @file_size
+    end
+
+    def default_serialization
+      {
+        "id" => self.id,
+        "parent" => self.parent_id,
+        "uuid" => self.uuid,
+        "file_path" => self.file_path,
+        "size_on_disk" => self.size_on_disk,
+        "context" => self.context,
+        "resource_type_id" => self.resource_type_id,
+        "effective_realm" => (self.effective_realm.nil? ? nil : self.effective_realm.name)
+      }
+    end
+
+    def self.find_by_parent(parent_id)
+      resources = []
+      DB.connect.exec("select resource_id, in_collection, file_path, " +
+                      "resource_uuid, file_size, context, resource_type_id " +
+                      "from content_resource " +
+                      "where in_collection=:parent_id", parent_id) do |row|
+        @@cache[row[0]] = ContentResource.new(row[0], row[1], row[2], row[3], row[4].to_i, row[5], row[6])
+        resources << @@cache[row[0]]
+      end
+      resources
+    end
+
+    def self.count_by_parent(parent_id)
+      count = 0
+      DB.connect.exec("select count(*) from content_resource " +
+                      "where in_collection=:parent_id", parent_id) do |row|
+        count = row[0].to_i
+      end
+      count
+    end
+  end
+
+  class ContentCollection < Content
+    def initialize(id, parent_id)
+      @id = id
+      @parent_id = parent_id
+
+      @table_name = "content_collection"
+      @id_column = "collection_id"
+    end
+
+    @@cache = {}
+    def self.find(id)
+      if id !~ /\/$/
+        id += "/"
+      end
+
+      if @@cache[id].nil?
+        DB.connect.exec("select collection_id, in_collection from content_collection " +
+                        "where collection_id=:id", id) do |row|
+          @@cache[id] = ContentCollection.new(row[0], row[1])
+        end
+        if @@cache[id].nil?
+          raise ObjectNotFoundException.new(ContentCollection, id)
+        end
+      end
+      @@cache[id]
+    end
+
+    # return a content collection, even if it's a missing one
+    def self.find!(id)
+      begin
+        ContentCollection.find(id)
+      rescue ObjectNotFoundException
+        MissingContentCollection.find(id)
+      end
+    end
+
+    def self.find_portfolio_interaction_collections
+      collections = []
+      DB.connect.exec("select collection_id, in_collection from content_collection " +
+                      "where collection_id like '%/portfolio-interaction/'") do |row|
+        @@cache[row[0]] = ContentCollection.new(row[0], row[1])
+        collections << @@cache[row[0]]
+      end
+      collections
+    end
+
+    def self.count_by_parent(parent_id)
+      count = 0
+      DB.connect.exec("select count(*) from content_collection " +
+                      "where in_collection=:parent_id", parent_id) do |row|
+        count = row[0].to_i
+      end
+      count
+    end
+
+    def size_on_disk
+      if @size_on_disk.nil?
+        DB.connect.exec("select sum(file_size) from content_resource " +
+                        "where resource_id like :collmatch", (@id + "%")) do |row|
+          @size_on_disk = row[0].to_i
+        end
+      end
+      @size_on_disk
+    end
+
+    def children
+      @child_collections ||= ContentCollection.find_by_parent(@id)
+      @child_resources ||= ContentResource.find_by_parent(@id)
+      {
+        "collections" => @child_collections,
+        "resources" => @child_resources
+      }
+    end
+
+    def child_counts
+      @child_collection_count ||= if @child_collections.nil?
+                                    ContentCollection.count_by_parent(@id)
+                                  else
+                                    @child_collections.length
+                                  end
+      @child_resource_count ||= if @child_resources.nil?
+                                  ContentResource.count_by_parent(@id)
+                                else
+                                  @child_resources.length
+                                end
+      {
+        "collections" => @child_collection_count,
+        "resources" => @child_resource_count,
+        "total" => @child_collection_count + @child_resource_count
+      }
+    end
+
+    def default_serialization
+      {
+        "id" => self.id,
+        "parent" => self.parent_id,
+        "size_on_disk" => self.size_on_disk,
+        "children" => self.child_counts,
+        "effective_realm" => (self.effective_realm.nil? ? nil : effective_realm.name)
+      }
+    end
+
+    def summary_serialization
+      {
+        "id" => self.id,
+        "parent" => self.parent_id
+      }
+    end
+
+    def children_serialization
+      {
+        "collections" => self.children["collections"].collect { |cc|
+          cc.serialize(:summary, :children)
+        },
+        "resources" => self.children["resources"].collect { |cr|
+          cr.serialize(:summary)
+        }
+      }
+    end
+
+    def self.find_by_parent(parent_id)
+      collections = []
+      DB.connect.exec("select collection_id, in_collection from content_collection " +
+                      "where in_collection = :parent_id", parent_id) do |row|
+        @@cache[row[0]] = ContentCollection.new(row[0], row[1])
+        collections << @@cache[row[0]]
+      end
+      collections
+    end
+  end
+
+  class MissingContentCollection < ContentCollection
+    @@cache = {}
+    def self.find(id)
+      @@cache[id] ||= MissingContentCollection.new(id, nil)
+    end
+
+    def size_on_disk
+      0
+    end
+  end
+end