def __AddInlineService(self, servicePackage):
        log.info("Importing inline service class %s",
                 servicePackage.inlineClass)

        # import the service class
        if '.' not in sys.path:
            sys.path.insert(0, '.')
        mod = __import__(servicePackage.name)

        # instantiate the service object
        serviceClass = getattr(mod, servicePackage.name)
        serviceObj = serviceClass()

        # instantiate the interface object
        serviceObjI = AGServiceI(serviceObj)
        serviceObjI.impl = serviceObj
        serviceObjI.auth_method_name = None

        # register the interface object
        pid = str(GUID())
        path = '/Services/' + servicePackage.name + '.' + pid
        self.server.RegisterObject(serviceObjI, path=path)
        serviceUrl = self.server.FindURLForObject(serviceObj)

        serviceObj.SetUri(serviceUrl)

        log.info("Service registered at url %s", serviceUrl)

        # Get the description from the service
        serviceDescription = serviceObj.GetDescription()
        serviceDescription.SetObject(serviceObj)
        serviceDescription.packageFile = servicePackage.packageFile

        return serviceObj, pid
        if self.started:
            self.Stop()

        # if enabled, start
        if self.enabled:
            self.Start()

    def SetResource(self, resource):
        """Set the resource used by this service"""

        self.log.info("VideoProducerService.SetResource : %s" %
                      resource.resource)
        self.resource = resource

    def SetIdentity(self, profile):
        """
        Set the identity of the user driving the node
        """
        self.log.info("SetIdentity: %s %s", profile.name, profile.email)
        self.profile = profile


if __name__ == '__main__':

    from AccessGrid.interfaces.AGService_interface import AGService as AGServiceI
    from AccessGrid.AGService import RunService

    service = MacVideoProducerService()
    serviceI = AGServiceI(service)
    RunService(service, serviceI)