def test_filtering(self):
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back([
            arc.Endpoint("test1.nordugrid.org", ["cap1", "cap2"]),
            arc.Endpoint("test2.nordugrid.org", ["cap3", "cap4"]),
            arc.Endpoint("test3.nordugrid.org", ["cap1", "cap3"])
        ])
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back([
            arc.Endpoint("test1.nordugrid.org", ["cap1", "cap2"]),
            arc.Endpoint("test2.nordugrid.org", ["cap3", "cap4"]),
            arc.Endpoint("test3.nordugrid.org", ["cap1", "cap3"])
        ])
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back([
            arc.Endpoint("test1.nordugrid.org", ["cap1", "cap2"]),
            arc.Endpoint("test2.nordugrid.org", ["cap3", "cap4"]),
            arc.Endpoint("test3.nordugrid.org", ["cap1", "cap3"])
        ])
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))
        registry = arc.Endpoint("test.nordugrid.org", arc.Endpoint.REGISTRY,
                                "org.nordugrid.sertest")

        options = arc.ServiceEndpointQueryOptions(False, ["cap1"])
        self.retriever = arc.ServiceEndpointRetriever(self.usercfg, options)
        container = arc.EndpointContainer()
        self.retriever.addConsumer(container)
        self.retriever.addEndpoint(registry)
        self.retriever.wait()
        self.expect(container).to_have(2).endpoints()

        options = arc.ServiceEndpointQueryOptions(False, ["cap2"])
        self.retriever = arc.ServiceEndpointRetriever(self.usercfg, options)
        container = arc.EndpointContainer()
        self.retriever.addConsumer(container)
        self.retriever.addEndpoint(registry)
        self.retriever.wait()
        self.expect(container).to_have(1).endpoint()

        options = arc.ServiceEndpointQueryOptions(False, ["cap5"])
        self.retriever = arc.ServiceEndpointRetriever(self.usercfg, options)
        container = arc.EndpointContainer()
        self.retriever.addConsumer(container)
        self.retriever.addEndpoint(registry)
        self.retriever.wait()
        self.expect(container).to_have(0).endpoints()
Example #2
0
    def test_resubmit(self):
        self.usercfg.Broker("TEST")

        arc.TargetInformationRetrieverPluginTESTControl.targets = [
            self.create_test_target("http://test2.nordugrid.org")
        ]
        arc.TargetInformationRetrieverPluginTESTControl.status = arc.EndpointQueryingStatus(
            arc.EndpointQueryingStatus.SUCCESSFUL)

        js = arc.JobSupervisor(self.usercfg, [
            self.create_test_job(
                job_id="http://test.nordugrid.org/1234567890test1",
                state=arc.JobState.FAILED),
            self.create_test_job(
                job_id="http://test.nordugrid.org/1234567890test2",
                state=arc.JobState.RUNNING)
        ])

        self.expect(js.GetAllJobs()).to_have(2).jobs()

        endpoints = [
            arc.Endpoint("http://test2.nordugrid.org",
                         arc.Endpoint.COMPUTINGINFO, "org.nordugrid.tirtest")
        ]
        resubmitted = arc.JobList()
        result = js.Resubmit(0, endpoints, resubmitted)
    def test_same_endpoint_is_not_queried_twice(self):
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back(
            [arc.Endpoint()])
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back(
            [arc.Endpoint()])
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))

        self.retriever = arc.ServiceEndpointRetriever(self.usercfg)
        container = arc.EndpointContainer()
        self.retriever.addConsumer(container)
        registry = arc.Endpoint("test.nordugrid.org", arc.Endpoint.REGISTRY,
                                "org.nordugrid.sertest")
        self.retriever.addEndpoint(registry)
        self.retriever.addEndpoint(registry)
        self.retriever.wait()
        self.expect(container).to_have(1).endpoint()
Example #4
0
 def test_getting_status_without_interfacename_specified(self):
     retriever = arc.TargetInformationRetriever(self.usercfg)
     container = arc.ComputingServiceContainer()
     retriever.addConsumer(container)
     arc.TargetInformationRetrieverPluginTESTControl.status = arc.EndpointQueryingStatus(
         arc.EndpointQueryingStatus.SUCCESSFUL, "TEST")
     self.ce.InterfaceName = ""
     retriever.addEndpoint(self.ce)
     retriever.wait()
     status = retriever.getStatusOfEndpoint(self.ce)
     self.expect(status).to_be(arc.EndpointQueryingStatus.SUCCESSFUL)
     self.expect(status.getDescription()).to_be("TEST")
Example #5
0
 def test_getting_status(self):
     retriever = arc.TargetInformationRetriever(self.usercfg)
     container = arc.ComputingServiceContainer()
     retriever.addConsumer(container)
     arc.TargetInformationRetrieverPluginTESTControl.status = arc.EndpointQueryingStatus(
         arc.EndpointQueryingStatus.SUCCESSFUL, "TEST")
     retriever.addEndpoint(self.ce)
     retriever.wait()
     status = retriever.getStatusOfEndpoint(self.ce)
     self.expect(status).to_be_an_instance_of(arc.EndpointQueryingStatus)
     self.expect(status).to_be(arc.EndpointQueryingStatus.SUCCESSFUL)
     self.expect(status.getDescription()).to_be("TEST")
Example #6
0
 def setUp(self):
     self.usercfg = arc.UserConfig(
         arc.initializeCredentialsType(
             arc.initializeCredentialsType.SkipCredentials))
     self.ce = arc.Endpoint()
     self.ce.URLString = "test.nordugrid.org"
     self.ce.InterfaceName = "org.nordugrid.tirtest"
     arc.TargetInformationRetrieverPluginTESTControl.delay = 0
     arc.TargetInformationRetrieverPluginTESTControl.targets = [
         arc.ComputingServiceType()
     ]
     arc.TargetInformationRetrieverPluginTESTControl.status = arc.EndpointQueryingStatus(
         arc.EndpointQueryingStatus.SUCCESSFUL)
    def test_recursivity_with_filtering(self):
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back([
            arc.Endpoint("emir.nordugrid.org", arc.Endpoint.REGISTRY,
                         "org.nordugrid.sertest"),
            arc.Endpoint("ce.nordugrid.org", arc.Endpoint.COMPUTINGINFO,
                         "org.ogf.glue.emies.resourceinfo"),
        ])
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back([
            arc.Endpoint("emir.nordugrid.org", arc.Endpoint.REGISTRY,
                         "org.nordugrid.sertest"),
            arc.Endpoint("ce.nordugrid.org", arc.Endpoint.COMPUTINGINFO,
                         "org.ogf.glue.emies.resourceinfo"),
        ])
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))

        options = arc.ServiceEndpointQueryOptions(
            True, ["information.discovery.resource"])
        self.retriever = arc.ServiceEndpointRetriever(self.usercfg, options)
        container = arc.EndpointContainer()
        self.retriever.addConsumer(container)
        registry = arc.Endpoint("test.nordugrid.org", arc.Endpoint.REGISTRY,
                                "org.nordugrid.sertest")
        self.retriever.addEndpoint(registry)
        self.retriever.wait()
        # expect to only get the ce.nordugrid.org, but that will be there twice
        # once from test.nordugrid.org, once from emir.nordugrid.org
        self.expect(container).to_have(2).endpoints()
        emirs = [
            endpoint for endpoint in container if "emir" in endpoint.URLString
        ]
        ces = [
            endpoint for endpoint in container if "ce" in endpoint.URLString
        ]
        self.expect(emirs).to_have(0).endpoints()
        self.expect(ces).to_have(2).endpoints()
    def test_status_of_typeless_registry(self):
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back(
            arc.EndpointList())
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))

        self.retriever = arc.ServiceEndpointRetriever(self.usercfg)
        container = arc.EndpointContainer()
        self.retriever.addConsumer(container)
        registry = arc.Endpoint("test.nordugrid.org", arc.Endpoint.REGISTRY)
        self.retriever.addEndpoint(registry)
        self.retriever.wait()
        status = self.retriever.getStatusOfEndpoint(registry)
        self.expect(status).to_be(arc.EndpointQueryingStatus.SUCCESSFUL)
    def test_deleting_the_consumer_before_the_retriever(self):
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back(
            arc.EndpointList())
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))

        self.retriever = arc.ServiceEndpointRetriever(self.usercfg)
        container = arc.EndpointContainer()
        self.retriever.addConsumer(container)
        registry = arc.Endpoint("test.nordugrid.org", arc.Endpoint.REGISTRY,
                                "org.nordugrid.sertest")
        self.retriever.addEndpoint(registry)
        self.retriever.removeConsumer(container)
        del container
        self.retriever.wait()
    def test_empty_registry_type(self):
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back(
            arc.EndpointList())
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))

        self.retriever = arc.ServiceEndpointRetriever(self.usercfg)
        container = arc.EndpointContainer()
        self.retriever.addConsumer(container)
        registry = arc.Endpoint("test.nordugrid.org", arc.Endpoint.REGISTRY)
        self.retriever.addEndpoint(registry)
        self.retriever.wait()
        # it should fill the empty type with the available plugins:
        # among them the TEST plugin which doesn't return any endpoint
        self.expect(container).to_have(0).endpoint()
 def setUp(self):
     self.usercfg = arc.UserConfig(
         arc.initializeCredentialsType(
             arc.initializeCredentialsType.SkipCredentials))
     self.ce = arc.Endpoint()
     self.ce.URLString = "test.nordugrid.org"
     self.ce.InterfaceName = "org.nordugrid.tirtest"
     self.ce.Capability.append(
         arc.Endpoint_GetStringForCapability(arc.Endpoint.COMPUTINGINFO))
     arc.TargetInformationRetrieverPluginTESTControl.delay = 0
     arc.TargetInformationRetrieverPluginTESTControl.targets = [
         self.create_test_target()
     ]
     arc.TargetInformationRetrieverPluginTESTControl.status = arc.EndpointQueryingStatus(
         arc.EndpointQueryingStatus.SUCCESSFUL)
    def test_getting_status(self):
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back(
            [arc.Endpoint()])
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.FAILED))

        self.retriever = arc.ServiceEndpointRetriever(self.usercfg)
        container = arc.EndpointContainer()
        self.retriever.addConsumer(container)
        registry = arc.Endpoint("test.nordugrid.org", arc.Endpoint.REGISTRY,
                                "org.nordugrid.sertest")
        self.retriever.addEndpoint(registry)
        self.retriever.wait()
        status = self.retriever.getStatusOfEndpoint(registry)
        self.expect(status).to_be_an_instance_of(arc.EndpointQueryingStatus)
        self.expect(status).to_be(arc.EndpointQueryingStatus.FAILED)
    def test_rejected_services(self):
        rejected = "http://test.nordugrid.org"
        not_rejected = "http://test2.nordugrid.org"
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back(
            [arc.Endpoint(rejected),
             arc.Endpoint(not_rejected)])
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))

        options = arc.ServiceEndpointQueryOptions(False, [], [rejected])
        self.retriever = arc.ServiceEndpointRetriever(self.usercfg, options)
        container = arc.EndpointContainer()
        self.retriever.addConsumer(container)

        registry = arc.Endpoint("registry.nordugrid.org",
                                arc.Endpoint.REGISTRY)
        self.retriever.addEndpoint(registry)
        self.retriever.wait()
        self.expect(container).to_have(1).endpoint()
        self.expect(container[0].URLString).to_be(not_rejected)
    def test_the_status_is_started_first(self):
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back(
            [arc.Endpoint()])
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))
        self.condition = arc.SimpleCondition()
        arc.ServiceEndpointRetrieverPluginTESTControl.condition.push_back(
            self.condition)

        self.retriever = arc.ServiceEndpointRetriever(self.usercfg)
        container = arc.EndpointContainer()
        self.retriever.addConsumer(container)
        registry = arc.Endpoint("test.nordugrid.org", arc.Endpoint.REGISTRY,
                                "org.nordugrid.sertest")
        self.retriever.addEndpoint(registry)
        status = self.retriever.getStatusOfEndpoint(registry)
        self.expect(status).to_be(arc.EndpointQueryingStatus.STARTED)
        self.condition.signal()
        self.retriever.wait()
        status = self.retriever.getStatusOfEndpoint(registry)
        self.expect(status).to_be(arc.EndpointQueryingStatus.SUCCESSFUL)
    def test_constructor_returns_immediately(self):
        arc.ServiceEndpointRetrieverPluginTESTControl.endpoints.push_back(
            [arc.Endpoint()])
        arc.ServiceEndpointRetrieverPluginTESTControl.status.push_back(
            arc.EndpointQueryingStatus(arc.EndpointQueryingStatus.SUCCESSFUL))
        self.condition = arc.SimpleCondition()
        arc.ServiceEndpointRetrieverPluginTESTControl.condition.push_back(
            self.condition)

        self.retriever = arc.ServiceEndpointRetriever(self.usercfg)
        container = arc.EndpointContainer()
        self.retriever.addConsumer(container)
        registry = arc.Endpoint("test.nordugrid.org", arc.Endpoint.REGISTRY,
                                "org.nordugrid.sertest")
        self.retriever.addEndpoint(registry)
        # the endpoint should not arrive yet
        self.expect(container).to_have(0).endpoints()
        self.condition.signal()
        # we are not interested in it anymore
        self.retriever.removeConsumer(container)
        # we must wait until self.retriever is done otherwise 'condition' will go out of scope while being used.
        self.retriever.wait()