omf_sfa 0.1.1

data/lib/omf-sfa/am/am_runner.rb

@@ -0,0 +1,108 @@
+
+require 'omf-sfa/am'
+require 'thin'
+
+# Add code to Thin::Connection to verify peer certificate
+#
+module Thin
+  class Connection
+    def ssl_verify_peer(cert_s)
+      true # will be verified later
+    end
+  end
+end
+
+module OMF::SFA::AM
+  class Runner < Thin::Runner
+    @@instance = nil
+
+    def self.instance
+      @@instance
+    end
+
+    def initialize(argv, opts = {})
+      raise "SINGLETON" if @@instance
+
+      @argv = argv
+      sopts = opts.delete(:ssl) # runner has it's own idea of ssl options
+
+      # Default options values
+      @options = {
+        :chdir                => Dir.pwd,
+        :environment          => 'development',
+        :address              => '0.0.0.0',
+        :port                 => Thin::Server::DEFAULT_PORT,
+        :timeout              => Thin::Server::DEFAULT_TIMEOUT,
+        :log                  => 'log/thin.log',
+        :pid                  => 'tmp/pids/thin.pid',
+        :max_conns            => Thin::Server::DEFAULT_MAXIMUM_CONNECTIONS,
+        :max_persistent_conns => Thin::Server::DEFAULT_MAXIMUM_PERSISTENT_CONNECTIONS,
+        :require              => [],
+        :wait                 => Thin::Controllers::Cluster::DEFAULT_WAIT_TIME
+      }.merge(opts)
+
+      print_options = false
+      p = parser
+      p.separator ""
+      p.separator "Datamapper options:"
+      p.on("--dm-db URL", "Datamapper database [#{@options[:dm_db]}]") do |u| @options[:dm_db] = u end
+      p.on("--dm-log FILE", "Datamapper log file [#{@options[:dm_log]}]") do |n| @options[:dm_log] = n end
+      p.on("--dm-auto-upgrade", "Run Datamapper's auto upgrade") do |n| @options[:dm_auto_upgrade] = true end
+      p.separator ""
+      p.separator "Testing options:"
+      p.on("--test-load-am", "Load an AM configuration for testing") do |n| @options[:load_test_am] = true end
+      p.on("--disable-https", "Run server without SSL") do sopts = nil end
+      p.on("--print-options", "Print option settings after parsing command lines args") do print_options = true end
+      p.separator ""
+      p.separator "Common options:"
+
+      parse!
+
+      if sopts
+        @options[:ssl] = true
+        @options[:ssl_key_file] ||= sopts[:key_file]
+        @options[:ssl_cert_file] ||= sopts[:cert_file]
+        @options[:ssl_verify] ||= sopts[:verify_peer]
+      end
+
+      if print_options
+        require 'pp'
+        pp @options
+      end
+
+      @@instance = self
+    end
+
+    def init_data_mapper
+
+      # Configure the data store
+      #
+      #DataMapper::Logger.new(@options[:dm_log] || $stdout, :debug)
+      DataMapper::Logger.new($stdout, :info)
+      #DataMapper::Logger.new(STDOUT, :debug)
+
+      #DataMapper.setup(:default, config[:data_mapper] || {:adapter => 'yaml', :path => '/tmp/am_test2'})
+      DataMapper.setup(:default, @options[:dm_db])
+
+      require 'omf-sfa/resource'
+      DataMapper::Model.raise_on_save_failure = true
+      DataMapper.finalize
+
+      # require  'dm-migrations'
+      # DataMapper.auto_migrate!
+
+      DataMapper.auto_upgrade! if @options[:dm_auto_upgrade]
+
+      load_test_am if @options[:load_test_am]
+
+    end
+
+    def run!
+      init_data_mapper
+      super
+    end
+  end
+end
+
+
+

data/lib/omf-sfa/am/am_scheduler.rb

@@ -0,0 +1,146 @@
+
+require 'omf_base/lobject'
+require 'omf-sfa/resource'
+require 'omf-sfa/resource/comp_group'
+require 'omf-sfa/am/am_manager'
+require 'omf-sfa/am/am_liaison'
+require 'active_support/inflector'
+
+
+module OMF::SFA::AM
+
+  extend OMF::SFA::AM
+
+  # This class implements a default resource scheduler
+  #
+  class AMScheduler < OMF::Base::LObject
+
+    # Create a resource of specific type given its description in a hash. If the type
+    # or the resource is physical then we create a clone of itself and assign it to
+    # the user who asked for it (conceptually a physical resource even though it is exclusive,
+    # is never given to the user but instead we provide him a clone of the resource).
+    # If the type is a 'lease' then we normally create a lease object.
+    #
+    # @param [Hash] resource_descr contains the properties of the new resource
+    # @param [String] The type of the resource we want to create
+    # @param [Hash] oproperties is a hash with all the OProperty values of the new resource
+    # @param [Authorizer] Defines context for authorization decisions
+    # @return [OResource] Returns the created resource
+    #
+    def create_resource(resource_descr, type_to_create, oproperties, authorizer)
+      debug "create_resource: resource_descr:'#{resource_descr}' type_to_create:'#{type_to_create}' oproperties:'#{oproperties}' authorizer:'#{authorizer.inspect}'"
+      if type_to_create.eql?('node')
+        desc = resource_descr.dup
+        desc[:account] = get_nil_account()
+
+        type = type_to_create.camelize
+
+        base_resource = eval("OMF::SFA::Resource::#{type}").first(desc)
+
+        if base_resource.nil? || !base_resource.available
+          raise UnknownResourceException.new "Resource '#{desc.inspect}' is not available or doesn't exist"
+        end
+
+        # create a clone
+        vr = base_resource.clone
+
+        vr.account = authorizer.account
+        vr.provided_by = base_resource
+        vr.save
+
+        base_resource.provides << vr
+        base_resource.save
+
+        return vr
+      elsif type_to_create.eql?('OLease')
+        resource_descr[:resource_type] = type_to_create
+        lease = OMF::SFA::Resource::OLease.create(resource_descr)
+        lease.valid_from = oproperties[:valid_from]
+        lease.valid_until = oproperties[:valid_until]
+        #lease.status = :pending
+        raise UnavailableResourceException.new "Cannot create '#{resource_descr.inspect}'" unless lease.save
+        return lease
+      else
+        raise "Uknown type of resource '#{type_to_create}'. Expected one of 'Node' or 'OLease'"
+      end
+    end
+
+    # Releases/destroys the given resource
+    #
+    # @param [OResource] The actual resource we want to destroy
+    # @param [Authorizer] Defines context for authorization decisions
+    # @return [Boolean] Returns true for success otherwise false
+    #
+    def release_resource(resource, authorizer)
+      debug "release_resource: resource-> '#{resource.to_json}'"
+      unless resource.is_a? OMF::SFA::Resource::OResource
+        raise "Expected OResource but got '#{resource.inspect}'"
+      end
+
+      base = resource.provided_by
+
+      unless resource.leases.empty?
+        base.leases.each do |l|
+          if (l.id == resource.leases.first.id)
+            time = Time.now
+            if (l.valid_until <= time)
+              l.status = "past"
+            else
+              l.status = "cancelled"
+            end
+          end
+        end
+        msg = resource.leases.first.component_leases.destroy!
+        raise "Failed to destroy component_leases" unless msg
+      end
+      resource = resource.destroy!
+      raise "Failed to destroy resource" unless resource
+      resource
+    end
+
+    # Accept or reject the reservation of the component
+    #
+    # @param [OLease] lease contains the corresponding reservation window
+    # @param [OComponent] component is the resource we want to reserve
+    # @return [Boolean] returns true or false depending on the outcome of the request
+    #
+    def lease_component(lease, component)
+      # TODO: Implement a basic FCFS for the competing leases of a component.
+      # Basic Component provides itself(clones) so many times as the accepted leases on it.
+      debug "lease_component: lease:'#{lease.name}' to component:'#{component.name}'"
+
+      base = component.provided_by
+      base.leases.each do |l|
+        if (lease.valid_from >= l.valid_until || lease.valid_until <= l.valid_from)
+          #all ok, do nothing
+        elsif (lease.valid_from <= l.valid_from && lease.valid_until > l.valid_from)#overlapping time
+          raise UnavailableResourceException.new "Cannot lease '#{component.name}', because it is unavailable for the requested time."
+        elsif (lease.valid_from >= l.valid_from && lease.valid_from <= l.valid_until)#overlapping time
+          raise UnavailableResourceException.new "Cannot lease '#{component.name}', because it is unavailable for the requested time."
+        end
+      end
+      lease.status = "accepted"
+      base.leases << lease
+      base.save
+      component.leases << lease
+      component.save
+      #@am_liaison.enable_lease(lease, component)
+      return true
+    end
+
+    # It returns the default account, normally used for admin account.
+    #
+    # @return [OAccount] returns the default account object
+    #
+    def get_nil_account()
+        @nil_account
+    end
+
+    def initialize()
+      @nil_account = OMF::SFA::Resource::OAccount.new(:name => '__default__', :valid_until => Time.now + 1E10)
+      @am_liaison = OMF::SFA::AM::AMLiaison.new
+    end
+
+  end # OMFManager
+
+end # OMF::SFA::AM

data/lib/omf-sfa/am/am_server.rb

@@ -0,0 +1,194 @@
+require 'rubygems'
+require 'rack'
+require 'rack/showexceptions'
+require 'thin'
+require 'dm-migrations'
+require 'omf_base/lobject'
+require 'omf_base/load_yaml'
+
+require 'omf-sfa/am/am_runner'
+require 'omf-sfa/am/am_manager'
+require 'omf-sfa/am/am_scheduler'
+require 'omf-sfa/am/am_liaison'
+
+
+module OMF::SFA::AM
+
+  class AMServer
+    # Don't use LObject as we haveb't initialized the logging system yet. Happens in 'init_logger'
+    include OMF::Base::Loggable
+    extend OMF::Base::Loggable
+
+    @@config = OMF::Base::YAML.load('omf-sfa-am', :path => [File.dirname(__FILE__) + '/../../../etc/omf-sfa'])[:omf_sfa_am]
+    @@rpc = @@config[:endpoints].select { |v| v[:type] == 'xmlrpc' }.first
+
+    def self.rpc_config
+      @@rpc
+    end
+
+    def init_logger
+      OMF::Base::Loggable.init_log 'am_server', :searchPath => File.join(File.dirname(__FILE__), 'am_server')
+    end
+
+    def check_dependencies
+      raise "xmlsec1 is not installed!" unless system('which xmlsec1 > /dev/null 2>&1')
+    end
+
+    def load_trusted_cert_roots
+
+      trusted_roots = File.expand_path(@@rpc[:trusted_roots])
+      certs = Dir.entries(trusted_roots)
+      certs.delete("..")
+      certs.delete(".")
+      certs.each do |fn|
+        fne = File.join(trusted_roots, fn)
+        if File.readable?(fne)
+          begin
+            trusted_cert = OpenSSL::X509::Certificate.new(File.read(fne))
+            OpenSSL::SSL::SSLContext::DEFAULT_CERT_STORE.add_cert(trusted_cert)
+          rescue OpenSSL::X509::StoreError => e
+            if e.message == "cert already in hash table"
+              warn "X509 cert '#{fne}' already registered in X509 store"
+            else
+              raise e
+            end
+          end
+        else
+          warn "Can't find trusted root cert '#{trusted_roots}/#{fne}'"
+        end
+      end
+    end
+
+    def init_data_mapper(options)
+      #@logger = OMF::Base::Loggable::_logger('am_server')
+      #OMF::Base::Loggable.debug "options: #{options}"
+      debug "options: #{options}"
+
+      # Configure the data store
+      #
+      DataMapper::Logger.new(options[:dm_log] || $stdout, :info)
+      #DataMapper::Logger.new($stdout, :info)
+
+      #DataMapper.setup(:default, config[:data_mapper] || {:adapter => 'yaml', :path => '/tmp/am_test2'})
+      DataMapper.setup(:default, options[:dm_db])
+
+      require 'omf-sfa/resource'
+      DataMapper::Model.raise_on_save_failure = true
+      DataMapper.finalize
+
+      # require  'dm-migrations'
+      # DataMapper.auto_migrate!
+
+      DataMapper.auto_upgrade! if options[:dm_auto_upgrade]
+    end
+
+
+    def load_test_am(options)
+      require  'dm-migrations'
+      DataMapper.auto_migrate!
+
+      am = options[:am][:manager]
+      if am.is_a? Proc
+        am = am.call
+        options[:am][:manager] = am
+      end
+
+      require 'omf-sfa/resource/oaccount'
+      #account = am.find_or_create_account(:name => 'foo')
+      account = OMF::SFA::Resource::OAccount.new(:name => 'foo')
+
+      require 'omf-sfa/resource/link'
+      require 'omf-sfa/resource/node'
+      require 'omf-sfa/resource/interface'
+      # nodes = {}
+      # 3.times do |i|
+        # name = "n#{i}"
+        # nodes[name] = n = OMF::SFA::Resource::Node.create(:name => name)
+        # am.manage_resource(n)
+      # end
+
+      r = []
+      r << l = OMF::SFA::Resource::Link.create(:name => 'l')
+      r << OMF::SFA::Resource::Channel.create(:number => 1, :frequency => "2.412GHZ")
+      lease = OMF::SFA::Resource::OLease.create(:name => 'l1', :valid_from => Time.now, :valid_until => Time.now + 3600)
+      2.times do |i|
+        r << n = OMF::SFA::Resource::Node.create(:name => "node#{i}")
+        ifr = OMF::SFA::Resource::Interface.create(name: "node#{i}:if0", node: n, channel: l)
+        ip = OMF::SFA::Resource::Ip.create(address: "10.0.1.#{i}", netmask: "255.255.255.0", ip_type: "ipv4", interface: ifr)
+        n.interfaces << ifr
+        l.interfaces << ifr
+        n.leases << lease
+      end
+      r.last.leases << OMF::SFA::Resource::OLease.create(:name => 'l2', :valid_from => Time.now + 3600, :valid_until => Time.now + 7200)
+
+      am.manage_resources(r)
+    end
+
+    def init_am_manager(opts = {})
+      @am_manager = OMF::SFA::AM::AMManager.new(OMF::SFA::AM::AMScheduler.new)
+      (opts[:am] ||= {})[:manager] = @am_manager
+    end
+
+    def run(opts)
+      @am_manager = nil
+
+      # alice = OpenSSL::X509::Certificate.new(File.read('/Users/max/.gcf/alice-cert.pem'))
+      # puts "ALICE::: #{OpenSSL::SSL::SSLContext::DEFAULT_CERT_STORE.verify(alice)}"
+      opts[:handlers] = {
+        # Should be done in a better way
+        :pre_rackup => lambda {
+        },
+        :pre_parse => lambda do |p, options|
+          p.on("--test-load-am", "Load an AM configuration for testing") do |n| options[:load_test_am] = true end
+          p.separator ""
+          p.separator "Datamapper options:"
+          p.on("--dm-db URL", "Datamapper database [#{options[:dm_db]}]") do |u| options[:dm_db] = u end
+          p.on("--dm-log FILE", "Datamapper log file [#{options[:dm_log]}]") do |n| options[:dm_log] = n end
+          p.on("--dm-auto-upgrade", "Run Datamapper's auto upgrade") do |n| options[:dm_auto_upgrade] = true end
+          p.separator ""
+        end,
+        :pre_run => lambda do |opts|
+          puts "OPTS: #{opts.inspect}"
+          init_logger()
+          check_dependencies()
+          load_trusted_cert_roots()
+          init_data_mapper(opts)
+          init_am_manager(opts)
+          load_test_am(opts) if opts[:load_test_am]
+        end
+      }
+
+
+      #Thin::Logging.debug = true
+      require 'omf_base/thin/runner'
+      OMF::Base::Thin::Runner.new(ARGV, opts).run!
+    end
+
+  end # class
+end # module
+
+# Configure the web server
+#
+rpc = OMF::SFA::AM::AMServer.rpc_config()
+opts = {
+  :app_name => 'am_server',
+  :port => 8001,
+  :am => {
+    #:manager => lambda { OMF::SFA::AM::AMManager.new(OMF::SFA::AM::AMScheduler.new) },
+    :liaison => OMF::SFA::AM::AMLiaison.new
+  },
+  :ssl => {
+    :cert_file => File.expand_path(rpc[:ssl][:cert_chain_file]),
+    :key_file => File.expand_path(rpc[:ssl][:private_key_file]),
+    :verify_peer => true
+    #:verify_peer => false
+  },
+  #:log => '/tmp/am_server.log',
+  :dm_db => 'sqlite:///tmp/am_test.db',
+  :dm_log => '/tmp/am_server-dm.log',
+  :rackup => File.dirname(__FILE__) + '/config.ru',
+}
+OMF::SFA::AM::AMServer.new.run(opts)
+
+
+

data/lib/omf-sfa/am/config.ru

@@ -0,0 +1,122 @@
+
+
+#RPC_URL = '/rpc'
+RPC_URL = '/RPC2'
+
+REQUIRE_LOGIN = false
+
+require 'rack/file'
+class MyFile < Rack::File
+  def call(env)
+    c, h, b = super
+    #h['Access-Control-Allow-Origin'] = '*'
+    [c, h, b]
+  end
+end
+
+
+# There seem to be some issues with teh sfi.py tool
+#use Rack::Lint
+
+#am_mgr = opts[:am][:manager]
+#sleep 10
+opts = OMF::Base::Thin::Runner.instance.options
+#puts self.methods.sort.inspect
+am_mgr = opts[:am][:manager]
+if am_mgr.is_a? Proc
+  am_mgr = am_mgr.call()
+end
+
+require 'omf-sfa/am/am-rest/session_authenticator'
+use OMF::SFA::AM::Rest::SessionAuthenticator, #:expire_after => 10,
+          :login_url => (REQUIRE_LOGIN ? '/login' : nil),
+          :no_session => ['^/$', "^#{RPC_URL}", '^/login', '^/logout', '^/readme', '^/assets']
+
+
+map RPC_URL do
+  require 'omf-sfa/am/am-rpc/am_rpc_service'
+  service = OMF::SFA::AM::RPC::AMService.new({:manager => am_mgr, :liaison => opts[:am][:liaison]})
+
+  app = lambda do |env|
+    [404, {"Content-Type" => "text/plain"}, ["Not found"]]
+  end
+
+  run Rack::RPC::Endpoint.new(app, service, :path => '')
+end
+
+map '/slices' do
+  require 'omf-sfa/am/am-rest/account_handler'
+  run OMF::SFA::AM::Rest::AccountHandler.new(opts[:am][:manager], opts)
+end
+
+
+map "/resources" do
+  require 'omf-sfa/am/am-rest/resource_handler'
+  # account = opts[:am_mgr].get_default_account()  # TODO: Is this still needed?
+  # run OMF::SFA::AM::Rest::ResourceHandler.new(opts[:am][:manager], opts.merge({:account => account}))
+    run OMF::SFA::AM::Rest::ResourceHandler.new(opts[:am][:manager], opts)
+end
+
+if REQUIRE_LOGIN
+  map '/login' do
+    require 'omf-sfa/am/am-rest/login_handler'
+    run OMF::SFA::AM::Rest::LoginHandler.new(opts[:am][:manager], opts)
+  end
+end
+
+map "/readme" do
+  require 'bluecloth'
+  s = File::read(File.dirname(__FILE__) + '/am-rest/REST_API.md')
+  frag = BlueCloth.new(s).to_html
+  wrapper = %{
+<html>
+  <head>
+    <title>AM REST API</title>
+    <link href="/assets/css/default.css" media="screen" rel="stylesheet" type="text/css">
+    <style type="text/css">
+   circle.node {
+     stroke: #fff;
+     stroke-width: 1.5px;
+   }
+
+      line.link {
+        stroke: #999;
+        stroke-opacity: .6;
+        stroke-width: 2px;
+
+      }
+</style>
+  </head>
+  <body>
+%s
+  </body>
+</html>
+}
+  p = lambda do |env|
+  puts "#{env.inspect}"
+
+    return [200, {"Content-Type" => "text/html"}, [wrapper % frag]]
+  end
+  run p
+end
+
+map '/assets' do
+  run MyFile.new(File.dirname(__FILE__) + '/../../../../share/assets')
+end
+
+map "/" do
+  handler = Proc.new do |env|
+    req = ::Rack::Request.new(env)
+    case req.path_info
+    when '/'
+      [301, {'Location' => '/readme', "Content-Type" => ""}, ['Next window!']]
+    when '/favicon.ico'
+      [301, {'Location' => '/assets/image/favicon.ico', "Content-Type" => ""}, ['Next window!']]
+    else
+      OMF::Base::Loggable.logger('rack').warn "Can't handle request '#{req.path_info}'"
+      [401, {"Content-Type" => ""}, "Sorry!"]
+    end
+  end
+  run handler
+end
+