omf_sfa 0.1.1

data/share/assets/network.js

@@ -0,0 +1,82 @@
+var w = 960,
+    h = 500,
+    fill = d3.scale.category20();
+
+var vis = d3.select("#chart")
+  .append("svg:svg")
+    .attr("width", w)
+    .attr("height", h);
+
+d3.json("http://0.0.0.0:8001/resources?json", function(json) {
+  var resources = json['resources_response']['resources']
+  var i2n = {};
+  var nodes = _.filter(resources, function(n) {
+	if (n['sfa_class'] == "node") {
+		 _.each(n['interfaces'], function(i) {
+			 i2n[i['href']] = n;
+		 });
+		 return true;
+	}
+	return false;
+  });
+  
+  var links = _.filter(resources, function(l) {
+    if (l['sfa_class'] == "link") {
+    	var src = l.interfaces[0].href;
+    	var tgt = l.interfaces[1].href;
+    	l.source = i2n[src];
+    	l.target = i2n[tgt];
+    	return l.source && l.target;
+    } 
+    return false;
+  });
+  
+  var force = d3.layout.force()
+      .charge(-1000)
+      .distance(100)
+      .nodes(nodes)
+      .links(links)
+      .size([w, h])
+      .start();
+
+  var link = vis.selectAll("line.link")
+      .data(links)
+    .enter().append("svg:line")
+      .attr("class", "link")
+      .attr("x1", function(d) { 
+    	  return d.source.x; 
+       })
+      .attr("y1", function(d) { return d.source.y; })
+      .attr("x2", function(d) { return d.target.x; })
+      .attr("y2", function(d) { return d.target.y; });
+
+  var node = vis.selectAll("circle.node")
+      .data(nodes)
+    .enter().append("svg:circle")
+      .attr("class", "node")
+      .attr("cx", function(d) { return d.x; })
+      .attr("cy", function(d) { return d.y; })
+      .attr("r", 20)
+      .style("fill", function(d) { return fill(d.group); })
+      .call(force.drag);
+
+  node.append("svg:title")
+      .text(function(d) { 
+    	  return d.component_name; 
+      });
+
+  vis.style("opacity", 1e-6)
+    .transition()
+      .duration(1000)
+      .style("opacity", 1);
+
+  force.on("tick", function() {
+    link.attr("x1", function(d) { return d.source.x; })
+        .attr("y1", function(d) { return d.source.y; })
+        .attr("x2", function(d) { return d.target.x; })
+        .attr("y2", function(d) { return d.target.y; });
+
+    node.attr("cx", function(d) { return d.x; })
+        .attr("cy", function(d) { return d.y; });
+  });
+});

data/spec/am/am-rest/common.rb

@@ -0,0 +1,29 @@
+
+require "#{File.dirname(__FILE__)}/../resource/common"
+require 'omf-sfa/resource/oresource'
+require 'omf-sfa/resource/ogroup'
+require 'omf-sfa/resource/ocomponent'
+require 'json'
+
+class MockRequest
+  def initialize(opts = {})
+    @opts = opts
+  end
+  
+  def []=(k, v)
+    @opts[k] = v
+  end
+  
+  def [](k)
+    @opts[k]
+  end
+  
+  def method_missing(name, *args, &block)
+    return @opts[name]
+  end
+end
+
+def create_def_opts(ropts = {})
+  req = MockRequest.new(ropts)
+  {:req => req} #, :am_mgr => @mgr}
+end

data/spec/am/am-rest/resource_group_handler_XspecX.rb

@@ -0,0 +1,97 @@
+require "#{File.dirname(__FILE__)}/common"
+
+require 'omf-sfa/am/am-rest/resource_group_handler'
+require 'omf-sfa/resource/node'
+require 'omf-sfa/resource/group_component'
+
+include OMF::SFA::Resource
+include OMF::SFA::AM
+
+describe 'ResourceGroup handler' do
+  before :all do
+    init_dm
+  end
+  
+  before :each do
+    @h = ResourceGroupHandler.new
+    @req = MockRequest.new(:path => '/slices/foo')
+  end
+
+  
+  it 'can list empty group' do
+    g = GroupComponent.create(:name => 'foo')
+    g.save
+    
+    res = @h.on_get(g, :req => @req)
+    exp = {:group_response => {
+              :about => "/slices/foo",
+              'uuid' => g.uuid.to_s,     
+              "href" => "/slices/foo", 
+              "sfa_class" => "group",
+              "component_name" => "foo", 
+              "component_manager_id" => "authority+am", 
+              "component_id" => "urn:publicid:IDN+mytestbed.net+group+foo", 
+              "components" => []
+          }}
+    res.should == exp
+  end
+  
+  it 'can list with node and interface' do
+    g = GroupComponent.create(:name => 'foo')
+    g.contains_resources << (n = Node.create(:name => 'n1'))
+    n.interfaces << (if1 = Interface.create(:name => 'if1'))
+    g.save
+    
+    res = @h.on_get(g, :req => @req)
+    exp = {:group_response => {
+              :about => "/slices/foo",
+              'uuid' => g.uuid.to_s,    
+              "href" => "/slices/foo", 
+              "sfa_class" => "group",
+              "component_name" => "foo", 
+              "component_manager_id" => "authority+am", 
+              "component_id" => "urn:publicid:IDN+mytestbed.net+group+foo", 
+              "components" => [{
+                "href" => "/slices/resources/n1",
+                "uuid"=> n.uuid.to_s,
+                "sfa_class"=>"node",
+                "component_name"=>"n1",
+                "component_manager_id"=>"authority+am",
+                "component_id"=>"urn:publicid:IDN+mytestbed.net+node+n1",
+                "available" => "true",
+                "interfaces" => [{
+                  "href" => "/slices/resources/if1",
+                  "uuid" => if1.uuid.to_s,
+                  "component_name" => "if1",
+                  "component_manager_id" => "authority+am",
+                  "component_id" => "urn:publicid:IDN+mytestbed.net+interface+if1",
+                  "sfa_class" => "interface"
+                }]
+              }]
+          }}
+    res.should == exp
+  end
+
+  it 'can create a group on put' do
+    root = GroupComponent.create(:name => 'root')
+    
+    b = '<group component_id="urn:publicid:IDN+mytestbed.net+group+g1"/>'
+    opts = create_def_opts(:path => '/slices/foo/resources/r3', :body => b)
+    
+    res = @h.on_put(root.name, opts)
+    res.should == { :resource_response => {
+      :about => "/slices/foo/resources/r3", 
+      "href" => "/slices/foo/resources/r3", 
+      "available" => "true", 
+      "uuid" => r3.uuid.to_s, 
+      "component_name" => "r3", 
+      "component_manager_id" => "authority+am", 
+      "component_id" => "urn:publicid:IDN+mytestbed.net+node+r3", 
+      "sfa_class" => "node",
+      "interfaces" => []
+    }}
+  end
+  
+
+end
+

data/spec/am/am-rest/resource_handler_spec.rb

@@ -0,0 +1,204 @@
+require "#{File.dirname(__FILE__)}/common"
+
+require 'omf-sfa/am/am-rest/resource_handler'
+require 'omf-sfa/resource'
+
+include OMF::SFA::Resource
+include OMF::SFA::AM
+
+class CompA < OComponent
+  sfa_class 'compA'
+end
+
+describe 'Resource handler' do
+  before :all do
+    OMF::Common::Loggable.init_log 'test'
+    init_dm
+  end
+  
+  before :each do
+    @mgr = DefaultManager.new
+    @h = ResourceHandler.new @mgr
+    @opts = create_def_opts(:path => '/slices/foo/resources/moo')
+  end
+  
+  
+  def create_node(name)
+    OComponent.all(:name => name).each {|r| 
+      #puts "DESTROY >>> #{r}::#{r.name}"
+      r.destroy
+    }
+    OComponent.create(:name => name)
+  end
+      
+  
+  it 'can list basic resource' do
+    r = OResource.create(:name => 'moo')
+    @mgr.manage_resource(r)   
+     
+    exp = {:resource_response => {
+             :about => "/slices/foo/resources/moo",
+             :uuid => r.uuid.to_s,
+             :name => "moo",
+             :type => 'unknown'
+          }}
+    res = @h.on_get(r.uuid.to_s, @opts)
+    res.should == exp
+    
+    res2 = @h.on_get({:name => r.name}, @opts)
+    res2.should == exp
+    
+  end
+  
+  it 'can list basic components' do
+    r = CompA.create(:name => 'r1')
+    r.save
+    @mgr.manage_resource(r)    
+    
+    exp = {:resource_response => {
+             :about => "/slices/foo/resources/moo",
+             "uuid" => r.uuid.to_s,
+             "href" => "/slices/foo/resources/r1", 
+             "component_name" => "r1", 
+             "component_manager_id" => "authority+am", 
+             "component_id" => "urn:publicid:IDN+mytestbed.net+compA+r1", 
+             "sfa_class" => 'compA'
+          }}
+    res = @h.on_get(r.uuid.to_s, @opts)
+    res.should == exp
+
+#    res2 = @h.on_get(r.uuid.to_s, @opts)
+    @mgr.manage_resource(r)
+    opts = create_def_opts
+    account = opts[:account] = OAccount.new()
+    r.account = account
+    
+    res2 = @h.on_get({:name => r.component_name}, @opts)
+    res2.should == exp
+  end  
+  
+  it 'can list node with one interface' do
+    n = Node.create(:name => 'n1')
+    n.interfaces << (if1 = Interface.create(:name => 'if1'))
+    n.save
+    @mgr.manage_resource(n)
+    
+    res = @h.on_get(n.uuid.to_s, @opts)
+    exp = {:resource_response => {
+             :about => "/slices/foo/resources/moo",
+             "uuid" => n.uuid.to_s,
+             "href" => "/slices/foo/resources/n1", 
+             'available' => "true", 
+             "component_name" => "n1", 
+             "component_manager_id" => "authority+am", 
+             "component_id" => "urn:publicid:IDN+mytestbed.net+node+n1", 
+             "sfa_class" => "node",
+             "interfaces"=> [{
+               "href" => "/slices/foo/resources/if1",
+               "uuid" => if1.uuid.to_s,
+               "component_name" => "if1",
+               "component_manager_id" =>"authority+am",
+               "component_id" => "urn:publicid:IDN+mytestbed.net+interface+if1",
+               "sfa_class" => "interface"
+             }]
+          }}
+    res.should == exp
+  end
+  
+  it 'list components for various accounts' do
+    OComponent.find(:name => 'r1').each {|r| r.destroy}
+    r = OComponent.create(:name => 'r1')
+    @mgr.manage_resource(r)
+    account1 = OAccount.create()
+    r.account = account1
+    r.save
+#    account1 = opts[:account] = OAccount.new()
+    
+    opts = create_def_opts(:path => '/resources/moo', :account_id => account1.uuid.to_uri)
+    @mgr.get_requester_account(opts).should == account1
+    
+    r1h = {:name => 'r1'}
+    res = @h.on_get(r1h, opts)
+
+    account2 = OAccount.create()    
+    opts = create_def_opts(:path => '/resources/moo', :account_id => UUIDTools::UUID.random_create.to_uri)
+    lambda do
+      res = @h.on_get(r1h, opts)
+    end.should raise_error OMF::SFA::AM::UnknownAccountException
+    
+    opts = create_def_opts(:path => '/resources/moo', :account_id => account2.uuid.to_uri)
+    lambda do
+      res = @h.on_get(r1h, opts)
+    end.should raise_error OMF::SFA::AM::UnknownResourceException
+  end
+  
+  it 'can create a node on put' do
+    r3 =  Node.create(:name => 'mytestbed.net+node+r3')
+    r3.name.should == 'mytestbed.net+node+r3'
+    @mgr.manage_resource(r3)
+    r3.account.should == @mgr.get_default_account  # this test should really go somewhere else
+    
+    path = '/slices/foo/resources/r3'
+    b = '<node component_id="urn:publicid:IDN+mytestbed.net+node+r3"/>'
+    opts = create_def_opts(:path => '/slices/foo/resources/mytestbed.net+node+r3', :body => b)
+    res = @h.on_put({:name => 'mytestbed.net+node+r3'}, opts)
+    res.should == { :resource_response => {
+      :about => "/slices/foo/resources/mytestbed.net+node+r3", 
+      "href" => "/slices/foo/resources/mytestbed.net+node+r3", 
+      "available" => "true", 
+      "uuid" => r3.uuid.to_s, 
+      "component_name" => "r3", 
+      "component_manager_id" => "authority+am", 
+      "component_id" => "urn:publicid:IDN+mytestbed.net+node+r3", 
+      "sfa_class" => "node",
+      "interfaces" => []
+    }}
+  end
+  
+  it 'can create a group on put' do
+    root = OGroup.create(:name => 'root')
+    @mgr.manage_resource(root)
+    
+    path = '/slices/foo/resources'
+    b = "<group uuid='#{root.uuid}'><group name='g'/></group>"
+    opts = create_def_opts(:path => path, :body => b)
+    opts[:name_prefix] = path
+    
+    res = @h.on_put(root.uuid.to_s, opts)
+    g = OMF::SFA::Resource::OGroup.first(:name => 'g')
+    g.should_not nil
+        
+    res.should == { :resource_response => {
+      :about=>"/slices/foo/resources", 
+      :type=>"group",
+      :href=>"/slices/foo/resources", 
+      :uuid => root.uuid.to_s,
+      :resources => [{
+        :type=>"group", 
+        :name=>"g", 
+        :href=>"/slices/foo/resources/g", 
+        :uuid=> g.uuid.to_s,
+        :resources=>[]
+      }], 
+    }}     
+  end
+  
+  it 'can delete a node on delete' do
+    r = create_node('r1')
+    @mgr.manage_resource(r)
+    account1 = OAccount.create()
+    
+    opts = create_def_opts(:path => '/resources/moo', :account_id => account1.uuid.to_uri)
+    res = @h.on_delete({:name => 'r1'}, opts)
+
+    r.account = account1
+    r.save
+    r.account.should == account1
+    opts = create_def_opts(:path => '/resources/moo', :account_id => account1.uuid.to_uri)
+    @mgr.find_resource({:name => 'r1'}, opts).should == r
+    
+    res = @h.on_delete({:name => 'r1'}, opts)
+
+  end
+  
+end

data/spec/am/am-rpc/sfa_methods_spec.rb

@@ -0,0 +1,150 @@
+require 'omf-sfa/am/am-rpc/am_rpc_service'
+require 'omf-sfa/am/am_manager'
+require 'dm-migrations'
+
+include OMF::SFA::AM::RPC
+
+def init_dm
+  #setup database
+  DataMapper::Logger.new($stdout, :info)
+
+  DataMapper.setup(:default, 'sqlite::memory:')
+  #DataMapper.setup(:default, 'sqlite:///tmp/am_test.db')
+  DataMapper::Model.raise_on_save_failure = true
+  DataMapper.finalize
+
+  DataMapper.auto_migrate!
+end
+
+describe AMService do
+
+  init_dm
+  
+  before (:each) { DataMapper.auto_migrate! }
+
+  let (:manager) { double('am_manager') }
+
+  let(:authorizer) { double('authorizer') }
+
+  let (:am_rpc) do
+    @am_rpc = AMService.new(:manager => manager) 
+    @am_rpc.authorizer = authorizer
+    @am_rpc
+  end
+
+  it 'will respond to get_version' do
+
+    res = {
+      :geni_api => 1,
+      :omf_am => "0.1",
+      :ad_rspec_versions => [{
+      :type => 'ProtoGENI',
+      :version => '2',
+      :namespace => 'http://www.protogeni.net/resources/rspec/2',
+      :schema => 'http://www.protogeni.net/resources/rspec/2/ad.xsd',
+      :extensions => []
+    }]
+    }
+
+    am_rpc.get_version.should be_eql(res)
+  end
+
+  it 'will return all the resources of a slice' do
+    
+    account = OMF::SFA::Resource::OAccount.new(:urn => "urn:publicid:IDN+omf:test+account+1")
+    OMF::SFA::Resource::Node.create({:name => 'node1', :account => account})
+
+    authorizer.should_receive(:check_credentials).with(:ListResources, "urn:publicid:IDN+omf:test+account+1", "cred")
+
+    manager.should_receive(:find_or_create_account).with({:urn => "urn:publicid:IDN+omf:test+account+1"}, anything)
+
+    manager.stub(:find_all_components_for_account) do
+      res = OMF::SFA::Resource::OComponent.all(:account => account)
+    end
+
+    res = am_rpc.list_resources("cred", {"geni_available" => false, "geni_compressed" => false, "geni_slice_urn" => "urn:publicid:IDN+omf:test+account+1"})
+
+    req = Nokogiri.XML(res)
+    node = req.xpath('//xmlns:node').first
+    node[:component_name].should be_eql('node1')
+  end
+
+  it 'will create a sliver' do
+    account = OMF::SFA::Resource::OAccount.new(:urn => "urn:publicid:IDN+omf:test+account+1")
+    OMF::SFA::Resource::Node.create({:name => 'node1', :account => account})
+
+    authorizer.should_receive(:check_credentials).with(:CreateSliver, "urn:publicid:IDN+omf:test+account+1", "cred")
+
+    manager.should_receive(:find_or_create_account).with({:urn => "urn:publicid:IDN+omf:test+account+1"}, authorizer).and_return(account)
+
+    resources = OMF::SFA::Resource::OComponent.all(:account => account)
+    manager.should_receive(:update_resources_from_rspec).and_return(resources)
+
+    res = am_rpc.create_sliver("urn:publicid:IDN+omf:test+account+1", "cred", "rspecs_here", "users")
+
+    req = Nokogiri.XML(res)
+    node = req.xpath('//xmlns:node').first
+    node[:component_name].should be_eql('node1')
+  end
+
+  it "will return the status of a sliver" do
+
+    account = OMF::SFA::Resource::OAccount.new(:urn => "urn:publicid:IDN+omf:test+account+1")
+    OMF::SFA::Resource::Node.create({:name => 'node1', :account => account})
+
+    authorizer.should_receive(:check_credentials).with(:SliverStatus, "urn:publicid:IDN+omf:test+account+1", "cred")
+
+    manager.should_receive(:find_account).with({:urn => "urn:publicid:IDN+omf:test+account+1"}, authorizer).and_return(account)
+
+    manager.should_receive(:find_or_create_account).with({:urn => "urn:publicid:IDN+omf:test+account+1"}, anything)
+
+    manager.stub(:find_all_components_for_account) do
+      OMF::SFA::Resource::OComponent.all(:account => account)
+    end
+
+    res = am_rpc.sliver_status("urn:publicid:IDN+omf:test+account+1", "cred")
+    
+    res['geni_urn'].should be_eql("urn:publicid:IDN+omf:test+account+1")
+    node = res['geni_resources'].first
+    node['geni_urn'].should be_eql("urn:publicid:IDN+mytestbed.net+node+node1")
+  end
+
+  it "will renew a sliver" do
+    expiration_time = DateTime.new(2014).rfc3339
+
+    authorizer.should_receive(:check_credentials).with(:RenewSliver, "urn:publicid:IDN+omf:test+account+1", "cred")
+    
+    manager.should_receive(:renew_account_until).with({:urn => "urn:publicid:IDN+omf:test+account+1"}, expiration_time, authorizer)
+
+    am_rpc.renew_sliver("urn:publicid:IDN+omf:test+account+1", "cred", expiration_time)
+  end
+
+  it "will delete a sliver" do
+
+    OMF::SFA::Resource::OAccount.new(:urn => "urn:publicid:IDN+omf:test+account+1")
+
+    account = authorizer.should_receive(:check_credentials).with(:DeleteSliver, "urn:publicid:IDN+omf:test+account+1", "cred")
+
+    manager.stub(:close_account) do |slice_urn, auth|
+      account = OMF::SFA::Resource::OAccount.first(slice_urn)
+      account.close
+      account.save
+      account
+    end
+
+    am_rpc.delete_sliver("urn:publicid:IDN+omf:test+account+1", "cred")
+    account.should be_closed
+  end
+
+  it "will shutdown sliver" do
+
+    account = OMF::SFA::Resource::OAccount.new(:urn => "urn:publicid:IDN+omf:test+account+1")
+
+    authorizer.should_receive(:check_credentials).with(:Shutdown, "urn:publicid:IDN+omf:test+account+1", "cred")
+    manager.should_receive(:find_account).and_return(account)
+    authorizer.should_receive(:can_close_account?).with(account)
+
+    am_rpc.shutdown_sliver("urn:publicid:IDN+omf:test+account+1", "cred")
+    account.should be_closed
+  end
+end