def __init__(self, profileFile=None): """ """ self.profileFile = profileFile self.profileType = '' self.name = '' self.email = '' self.phoneNumber = '' self.icon = None self.publicId = str(GUID()) self.location = '' self.venueClientURL = '' self.homeVenue = '' self.privateId = '' self.distinguishedName = '' self.techSupportInfo = '' self.connectionId = '' if time.daylight: self.gmtoffset = time.altzone else: self.gmtoffset = time.timezone self.beacon = 0 self.video = self.audio = self.display = 0 self.lat = self.long = 0 if profileFile != None and os.path.exists(profileFile): self.Load(self.profileFile) else: self.profile = ClientProfile.defaultProfile.copy() self.profile['ClientProfile.id'] = self.publicId self._SetFromConfig() # Get the values from the config
def AddMimeType(self, name, extension, mimeType, startable="1"): """ returns a tuple of (int, string). Success is (1, mimeType), failure is (0, reason) """ # Ensure that we're in synch with the on-disk appdb self._Synch() namekey = self._GetPrivName(name) if namekey == None: namekey = str(GUID()) privName = self.defaultSeparator.join(["priv_names", namekey]) nameStr = self.defaultSeparator.join(["name", namekey]) extStr = self.defaultSeparator.join(["extension", extension]) mimeStr = self.defaultSeparator.join([mimeType, "None"]) startableStr = self.defaultSeparator.join(["startable", mimeType]) self.AppDb[privName] = name self.AppDb[nameStr] = mimeType self.AppDb[extStr] = mimeType self.AppDb[mimeStr] = None self.AppDb[startableStr] = startable self._Flush() return (1, mimeType)
def __init__(self, name, description, version, mimeType, extension): ''' Initiate the class. ** Arguments ** * name * name of the service. * description * description of the service. * version * service version. ''' self.name = name self.description = description self.version = version self.mimeType = mimeType self.extension = extension self.visible = 1 self.id = GUID() # Defined in Start. self.venueProxies = {} self.url = None self.log = None self.app = None # Standard AG initialization for console apps. self.app = CmdlineApplication.instance() self.app.AddCmdLineOption(Option("-v", "--venueUrl", dest="venueUrl", help="Register with venue located at this url.")) self.app.AddCmdLineOption(Option("-s", "--venueServerUrl", dest="venueServerUrl", help="Register with all venues at server located at this url.")) self.capabilities = []
def __init__(self): AGService.__init__(self) self.log.debug("DebugService.__init__: Init Service") self.id = str(GUID()) # Set capabilities self.capabilities = [ Capability(Capability.CONSUMER, Capability.AUDIO), Capability(Capability.CONSUMER, Capability.VIDEO), Capability(Capability.PRODUCER, "debug") ] # Set executable self.executable = None # Set configuration parameters self.param1 = OptionSetParameter("Configuration Parameter 1: ", "On", ["On", "Off"]) self.param2 = RangeParameter("Configuration Parameter 2: ", 0, 0, 100) self.param3 = TextParameter("Configuration Parameter 3: ", "DebugService") self.param4 = ValueParameter("Configuration Parameter 4: ", 25) # Append parameters to the configuration list self.configuration.append(self.param1) self.configuration.append(self.param2) self.configuration.append(self.param3) self.configuration.append(self.param4)
def __init__( self ): if self.__class__ == AGService: raise Exception("Can't instantiate abstract class AGService") self.name = str(self.__class__).split('.')[-1] self.uri = 0 self.serviceManagerUri = '' self.resource = None self.executable = "" self.streamDescription = None self.startPriority = "5" self.capabilities = [] self.startPriorityOption = OptionSetParameter("Start Priority", self.startPriority, self.START_PRIORITY_OPTIONS) self.configuration = [ self.startPriorityOption ] self.started = 1 self.enabled = 1 self.running = 1 self.packageFile = "" self.id = GUID() # Variable used by new service with AG3.1 interface to indicate when the server has first been configured # Afterwards relies on streamDescription comparision as with older AG3.0.x services. self.isConfigured = False self.processManager = ProcessManager() app = GetDefaultApplication() if not app: app = Service.instance() self.log = app.GetLog()
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
def _remove_plugin(self, name): namekey = self._get_priv_name(name) if namekey == None: namekey = str(GUID()) privName = self.defaultSeparator.join(['priv_names', namekey]) nameStr = self.defaultSeparator.join(['name', namekey]) desckey = self.defaultSeparator.join(['priv_desc', namekey]) cmdkey = self.defaultSeparator.join(['priv_cmds', namekey]) modulekey = self.defaultSeparator.join(['priv_modules', namekey]) iconkey = self.defaultSeparator.join(['priv_icons', namekey]) # # The ,None prevents an exception being thrown that we don't # care about, ie KeyError # self.PluginDb.pop(privName, None) self.PluginDb.pop(desckey, None) self.PluginDb.pop(cmdkey, None) self.PluginDb.pop(modulekey, None) self.PluginDb.pop(iconkey, None) self.Save() return True
def connectionMade(self, connection): # Setup a connection id for each connection connection.connectionId = GUID() # add connection to list, but it has no group yet self.connections[connection.connectionId] = (connection, None) log.info("connectionMade %s:%s", connection.getPeer().host, connection.getPeer().port)
def JoinBridge(self, multicastNetworkLocation): mnl = multicastNetworkLocation log.info("Bridge request: mcast %s %s" % (mnl["host"], str(mnl["port"]))) uaddr = SystemConfig.instance().GetHostname() retBridge = self.bridgeFactory.CreateBridge(id=mnl["id"], maddr=mnl["host"], mport=mnl["port"], mttl=mnl["ttl"], uaddr=uaddr, uport=None) networkLocation = UnicastNetworkLocation(host=retBridge.uaddr, port=retBridge.uport) networkLocation.profile = self.providerProfile networkLocation.id = GUID() networkLocation.privateId = GUID() return networkLocation
def __init__(self, parent): '''Starts event service''' self.uniqueId = str(GUID()) self.eventList = parent.eventsOut self.eventService = EventService((parent.host, int(parent.port))) self.eventService.start() self.eventService.AddChannel(self.uniqueId) self.lock = parent.sendLock self.nrOfEvent = parent.nrOfEvent
def testRegisterAndLookupBridges(self): from AccessGrid.Registry.RegistryClient import RegistryClient from AccessGrid.Descriptions import BridgeDescription, QUICKBRIDGE_TYPE, UMTP_TYPE from AccessGrid.GUID import GUID rc = RegistryClient(url=GetRegistryUrl()) guid1 = GUID() name1 = "name1" host1 = "host1" listenPort1 = 20001 serverType1 = QUICKBRIDGE_TYPE desc1 = "description1" bridgeDesc1 = BridgeDescription(guid=guid1, name=name1, host=host1, port=listenPort1, serverType=serverType1, description=desc1) validSecs1 = rc.RegisterBridge(bridgeDesc1) guid2 = GUID() name2 = "name2" host2 = "host2" listenPort2 = 20002 serverType2 = UMTP_TYPE desc2 = "description2" bridgeDesc2 = BridgeDescription(guid=guid2, name=name2, host=host2, port=listenPort2, serverType=serverType2, description=desc2) validSecs2 = rc.RegisterBridge(bridgeDesc2) results = rc.LookupBridge(5) found1 = False found2 = False for result in results: if self._bridgeDescriptionsMatch(result, bridgeDesc1): found1 = True if self._bridgeDescriptionsMatch(result, bridgeDesc2): found2 = True assert found1 assert found2
def AddNetworkLocation(self, networkLocation): """ Add the specified network location to the list Note: This method overwrites the network location id in the incoming network location """ networkLocation.id = str(GUID()) self.networkLocations.append(networkLocation) return networkLocation.id
def __init__(self): self.id = str(GUID()) self.location = None self.displayWidth = -1 self.displayHeight = -1 self.displayDepth = -1 self.windowList = list() self.regionList = list() self._Initialize()
def __ExecuteService(self, servicePackage): log.debug("Executing service %s", servicePackage.name) # # Start the service process # options = [] # # Determine executable # servicePath = self.__GetServicePath(servicePackage) exeFile = os.path.join(servicePath, servicePackage.executable) options.append(exeFile) # Set options for service # - port port = self.allocator.AllocatePort() options.append('--port') options.append(port) # - url of service manager to register with options.append('--serviceManagerUri') options.append(self.uri) # - a token that the service will pass when registering token = str(GUID()) options.append('--token') options.append(token) # - if service manager is insecure, services will be too if self.app.GetOption('secure'): options.append('--secure') log.info("Running Service; options: %s", str(options)) # Execute the service process pid = self.processManager.StartProcess(sys.executable, options) # Wait for service to register with me self.registeringServices[token] = None self.registerFlag.clear() self.registerFlag.wait(10) if self.registerFlag.isSet(): serviceUrl = self.registeringServices[token] log.info("Service registered: %s %s", serviceUrl, token) else: log.info("Service failed to register: %s", token) raise Exception("Service failed to become reachable") # Remove service from registration list del self.registeringServices[token] return serviceUrl, pid
def __init__(self, name=None, description=None, uri=None, oid=None): # Catch annoying None case if oid != None: self.id = oid else: self.id = str(GUID()) self.name = name self.description = description self.uri = uri
def __init__(self, host, port): ''' Starts text service **Arguments** *host* host where text service is running *port* port that text service is using ''' self.uniqueId = str(GUID()) self.textService = TextService((host, int(port))) self.textService.start() self.textService.AddChannel(self.uniqueId)
def __init__(self, parent): ''' Starts EventServiceSender ''' self.privateId = str(GUID()) self.eventOutList = parent.eventsOut self.eventReceivedList = [] self.lock = parent.sendLock self.nrOfEvent = parent.nrOfEvent self.parent = parent self.name = parent.index parent.index = parent.index + 1
def ping(host, port, count): try: # Create the text client profile = ClientProfile() textClient = TextClient(profile, (host, port)) # Connect and send privId = str(GUID()) textClient.Connect(channel, privId) # pubId = profile.GetPublicId() # for i in range(count): # textClient.Input("%s -- %d" % (pubId, i)) queue.put(0) except TextClientConnectException, e: print "EXCEPTION in text", sys.exc_type, sys.exc_value queue.put(2)
def RunClient(*args, **kw): m2threading.init() id = kw['id'] venueUri = kw['url'] app = kw['app'] iter = app.GetOption("rt") verbose = kw['verbose'] profile = ClientProfile() profile.name = "Test Client %s" % id profile.publicId = str(GUID()) client = MyVenueClient(profile, app) for i in range(iter): try: if verbose: print "Entering Venue: %s" % venueUri ret = client.EnterVenue(venueUri) if ret: print '** EnterVenue ret = ', ret print "Client %d Entered %s %d times" % (id, venueUri,i) except: print traceback.print_exc() continue if verbose: client.PrintVenueState() # Pick next one if client.venueState is not None: exits = client.venueState.connections.values() if len(exits): next_index = random.randint(0, len(exits)-1) venueUri = exits[next_index].uri try: time.sleep(1) client.ExitVenue() if verbose: print "Exited venue !" except: print traceback.print_exc() client.Shutdown() m2threading.cleanup()
def ping(host, port, count): try: privId = str(GUID()) eventClient = EventClient(privId, (host, port), channel) eventClient.Start() eventClient.Send(ConnectEvent(channel, privId)) for i in range(1, count): eventClient.Send(HeartbeatEvent(channel, "%s -- %d" % (privId, i))) queue.put(0) except EventClientConnectionException: print sys.exc_type, sys.exc_value queue.put(2) except: print sys.exc_type, sys.exc_value queue.put(3) done.set()
def __init__(self, parent): ''' Starts TextServiceSender **Arguments** *eventList* buffer where to insert sent events *lock* lock for eventList (also used by EventServiceController) *nrOfEvents* how many events of each type should get sent ''' self.parent = parent self.privateId = str(GUID()) self.eventList = parent.eventsOut self.receiveList = [] self.lock = parent.sendLock self.nrOfEvent = parent.nrOfMessages self.profile = ClientProfile() self.profile.name = "client" + str(self.parent.index) self.parent.index = self.parent.index + 1
def stringReceived(self, data): #print "lineReceived", data connection = self.transport sentOk = self.factory.sendGroupMessage(connection, data) if sentOk == False: if not self.factory.connectionHasGroup(connection): # Client is not in any group; treat data as connect string # parse connection string: grouplen,groupid,connectionlen,connectionid try: if len(data) == 32: # do beta1 compatibility handling groupId = data connectionId = GUID() log.info('beta1 compat: group=%s conn=%s' % (groupId, connectionId)) else: grouplen = int(data[:2]) groupId = data[2:grouplen + 2] connectionlen = int(data[grouplen + 2:grouplen + 4]) connectionId = data[grouplen + 4:grouplen + 4 + connectionlen] log.info('beta2+: groupid=%s; connectionid=%s' % (groupId, connectionId)) self.factory.addConnection(connection, groupId, connectionId) except GroupDoesNotExistException: self.sendError(ERROR.NO_SUCH_GROUP) self.transport.loseConnection() except: log.exception('Exception in group msg service connect') self.sendError(ERROR.UNKNOWN) self.transport.loseConnection() self.sendConnectResponse(connectionId=connection.connectionId) #print "Wrote version 1 response ack" #assert True==self.factory.connectionHasGroup(connection) else: # Existing connection. Unable to send for unspecified reason. log.debug('Client in group, but send failed') self.sendError(ERROR.SERVER_UNABLE_TO_SEND) self.transport.loseConnection()
def __init__(self, name=None, auth_type=None, auth_data=None, id=str(GUID())): """ @param name: the name of the subject @param auth_type: the type of authentication used for the subject @param auth_data: opaque authentication specific data @param id: a globally unique identifier for this object @type name: string @type auth_type: string @type auth_data: string @type id: a string containing a globally unique identifier """ self.name = name self.auth_type = auth_type self.auth_data = auth_data self.id = id
def __init__(self): self.dataPort = 9988 self.dataStoreClientList = [] self.uniqueId = GUID() # Start transfer service self.dataTransferServer = GSIHTTPTransferServer( ('', int(self.dataPort)), numThreads=4, sslCompat=0) self.dataTransferServer.run() self.CreateDataStore() # Basic test d = DataStoreClient(self.dataStore, 0) d.StartDataOperations() # Thread test #self.StartDataStoreClients() self.ShutDown()
def __init__(self): """ The constructor, initializes itself. """ self.id = str(GUID()) self.roles = list() self.actions = list() self.defaultRoles = list() self.defaultRoles.append(Everybody) self.parent = None self.rolesRequired = list() # Yeah, I know self.profileCachePrefix = "serverProfileCache" userConfig = UserConfig.instance() self.profileCachePath = os.path.join(userConfig.GetConfigDir(), self.profileCachePrefix) self.profileCache = ClientProfileCache(self.profileCachePath) self.identificationRequired = 0
def AddCommand(self, mimeType, cmdName, cmdString): """ returns a tuple (int, string). Success is (1, cmdName), failure is (0, reason). """ # Ensure that we're in synch with the on-disk appdb self._Synch() pCmd = self._GetPrivVerb(cmdName, mimeType) if pCmd == None: pCmd = str(GUID()) cmdkey = self.defaultSeparator.join([mimeType, pCmd]) pcmdkey = self.defaultSeparator.join(["priv_cmds", pCmd]) self.AppDb[cmdkey] = cmdString self.AppDb[pcmdkey] = cmdName self._Flush() return (1, cmdName)
def _add_plugin(self, name, description, command, module, icon): namekey = self._get_priv_name(name) if namekey == None: namekey = str(GUID()) privName = self.defaultSeparator.join(['priv_names', namekey]) nameStr = self.defaultSeparator.join(['name', namekey]) desckey = self.defaultSeparator.join(['priv_desc', namekey]) cmdkey = self.defaultSeparator.join(['priv_cmds', namekey]) modulekey = self.defaultSeparator.join(['priv_modules', namekey]) iconkey = self.defaultSeparator.join(['priv_icons', namekey]) self.PluginDb[privName] = name self.PluginDb[desckey] = description self.PluginDb[cmdkey] = command self.PluginDb[modulekey] = module self.PluginDb[iconkey] = icon self.Save() return True
def __init__(self, name, location, listenPort, qbexec, registryUrlList, portRange=None): if not os.path.exists(qbexec): raise Exception( "QuickBridge executable does not exist at this location:", qbexec) self.bridgeFactory = BridgeFactory(qbexec=qbexec, portRange=portRange, logger=log) self.providerProfile = ProviderProfile(name, location) self.listenPort = listenPort self.listeningServer = AsyncAGXMLRPCServerThreaded( ("", listenPort), intervalSecs=1, callback=self.MaintenanceCallback, logRequests=0) self._RegisterRemoteFunctions() self.registryClients = [] for registryUrl in registryUrlList: self.registryClients.append(RegistryClient(url=registryUrl)) hostname = SystemConfig.instance().GetHostname() self.bridgeDescription = BridgeDescription( guid=GUID(), name=name, host=hostname, port=self.listenPort, serverType=QUICKBRIDGE_TYPE, description="", portMin=self.bridgeFactory.GetPortMin(), portMax=self.bridgeFactory.GetPortMax()) self._RegisterWithRegistry() self.running = False
def __init__(self,vncserverexe,displayID,geometry="1024x768",depth=24): # Initialize the vncserver executable self.vncserverexe = vncserverexe # Initialize the contact string, construct it from the hostname and the # display ID hostname=Toolkit.CmdlineApplication.instance().GetHostname() if IsWindows(): self.contactString="%s"%(hostname,) elif IsOSX(): self.contactString="%s"%(hostname,) elif IsLinux() or IsFreeBSD(): self.contactString="%s%s"%(hostname,displayID) self.displayID=displayID # Initialize internal representation of the desired geometry self.geometry={} (tmpWidth,tmpHeight)=geometry.split('x') self.geometry["Width"]=eval(tmpWidth) self.geometry["Height"]=eval(tmpHeight) # And depth self.depth=depth # Initialize other random bits, mostly path/file names self.guid=str(GUID()) self.passwdFilename = None # Initialize the password file. self.genPassword() self.processManager = ProcessManager() self.running = 0
s.settimeout(2) s.bind(('', desc.GetPort())) s.sendto('qwe', (desc.host, desc.port)) fdList = select.select([s.fileno()], [], [], timeout) if fdList[0] and s.fileno() in fdList[0]: data, src_addr = s.recvfrom(MSGSIZE) ret = 1 except Exception, e: log.exception("Error testing bridge") if s: s.close() return ret def PingBridge(self): raise Exception("Not yet implemented") if __name__ == '__main__': bc = UMTPClient(host="milton.mcs.anl.gov", port=52000) multicastNetworkLocation = MulticastNetworkLocation(host="224.2.224.15", port=20002, ttl=1) multicastNetworkLocation.id = GUID() multicastNetworkLocation.privateId = GUID() multicastNetworkLocation.profile = ("", "") print dir(multicastNetworkLocation) print multicastNetworkLocation.__dict__ print "Multicast location: ", multicastNetworkLocation print "Test: ", bc.TestBridge(multicastNetworkLocation)