コード例 #1
0
ファイル: user_service.py プロジェクト: hanwoody/openuds
    def checkForRemoval(self, userService: UserService) -> None:
        """
        This method is used by UserService when a request for setInUse(False) is made
        This checks that the service can continue existing or not
        """
        osManager = userService.deployed_service.osmanager
        # If os manager says "machine is persistent", do not try to delete "previous version" assigned machines
        doPublicationCleanup = True if not osManager else not osManager.getInstance(
        ).isPersistent()

        if doPublicationCleanup:
            remove = False
            with transaction.atomic():
                userService = UserService.objects.select_for_update().get(
                    id=userService.id)
                activePublication = userService.deployed_service.activePublication(
                )
                if userService.publication and activePublication and userService.publication.id != activePublication.id:
                    logger.debug(
                        'Old revision of user service, marking as removable: %s',
                        userService)
                    remove = True

            if remove:
                userService.remove()
コード例 #2
0
ファイル: user_service.py プロジェクト: ZenBoy999/openuds
    def notifyPreconnect(self, userService: UserService, userName: str, protocol: str) -> None:
        '''
        Notifies a preconnect to an user service
        '''
        proxy = userService.deployed_service.proxy
        url = userService.getCommsUrl()
        ip, hostname = userService.getConnectionSource()

        if not url:
            logger.debug('No notification is made because agent does not supports notifications')
            return

        url += '/preConnect'

        try:
            data = {'user': userName, 'protocol': protocol, 'ip': ip, 'hostname': hostname}
            if proxy is not None:
                r = proxy.doProxyRequest(url=url, data=data, timeout=2)
            else:
                r = requests.post(
                    url,
                    data=json.dumps(data),
                    headers={'content-type': 'application/json'},
                    verify=False,
                    timeout=2
                )
            r = json.loads(r.content)
            logger.debug('Sent pre-connection to client using %s: %s', url, r)
            # In fact we ignore result right now
        except Exception as e:
            logger.info('preConnection failed: %s. Check connection on destination machine: %s', e, url)
コード例 #3
0
    def removeOrCancel(self, userService: UserService):
        if userService.isUsable() or State.isRemovable(userService.state):
            return self.remove(userService)

        if userService.isPreparing():
            return self.cancel(userService)

        raise OperationException(_('Can\'t remove nor cancel {} cause its state don\'t allow it').format(userService.name))
コード例 #4
0
ファイル: user_service.py プロジェクト: hanwoody/openuds
    def reset(self, userService: UserService) -> None:
        userService.refresh_from_db()

        if not userService.deployed_service.service.getType().canReset:
            return

        logger.debug('Reseting %s', userService)

        userServiceInstance = userService.getInstance()
        try:
            userServiceInstance.reset()
        except Exception:
            logger.exception('Reseting service')
コード例 #5
0
ファイル: user_service.py プロジェクト: hanwoody/openuds
    def remove(self, userService: UserService) -> UserService:
        """
        Removes a uService element
        """
        with transaction.atomic():
            userService = UserService.objects.select_for_update().get(
                id=userService.id)
            logger.debug('Removing userService %a', userService)
            if userService.isUsable() is False and State.isRemovable(
                    userService.state) is False:
                raise OperationException(
                    _('Can\'t remove a non active element'))
            userService.setState(State.REMOVING)
            logger.debug("***** The state now is %s *****",
                         State.toString(userService.state))
            userService.setInUse(
                False
            )  # For accounting, ensure that it is not in use right now
            userService.save()

        userServiceInstance = userService.getInstance()
        state = userServiceInstance.destroy()

        # Data will be serialized on makeUnique process
        UserServiceOpChecker.makeUnique(userService, userServiceInstance,
                                        state)

        return userService
コード例 #6
0
ファイル: user_service.py プロジェクト: hanwoody/openuds
    def cancel(self, userService: UserService) -> UserService:
        """
        Cancels an user service creation
        @return: the Uservice canceling
        """
        userService.refresh_from_db()
        logger.debug('Canceling userService %s creation', userService)

        if userService.isPreparing() is False:
            logger.info(
                'Cancel requested for a non running operation, performing removal instead'
            )
            return self.remove(userService)

        userServiceInstance = userService.getInstance()

        if not userServiceInstance.supportsCancel(
        ):  # Does not supports cancel, but destroy, so mark it for "later" destroy
            # State is kept, just mark it for destroy after finished preparing
            userService.setProperty('destroy_after', 'y')
        else:
            userService.setState(State.CANCELING)
            # We simply notify service that it should cancel operation
            state = userServiceInstance.cancel()

            # Data will be serialized on makeUnique process
            # If cancel is not supported, base cancel always returns "FINISHED", and
            # opchecker will set state to "removable"
            UserServiceOpChecker.makeUnique(userService, userServiceInstance,
                                            state)

        return userService
コード例 #7
0
ファイル: actor_v3.py プロジェクト: krishuang0610/openuds
 def process_logout(userService: UserService, username: str) -> None:
     """
     This method is static so can be invoked from elsewhere
     """
     osManager: typing.Optional[
         osmanagers.OSManager] = userService.getOsManagerInstance()
     if userService.in_use:  # If already logged out, do not add a second logout (windows does this i.e.)
         osmanagers.OSManager.loggedOut(userService, username)
         if osManager:
             if osManager.isRemovableOnLogout(userService):
                 logger.debug('Removable on logout: %s', osManager)
                 userService.remove()
         else:
             userService.remove()
コード例 #8
0
ファイル: opchecker.py プロジェクト: tanonl/openuds
    def checkAndUpdateState(userService: UserService,
                            userServiceInstance: UserDeployment, state: str):
        """
        Checks the value returned from invocation to publish or checkPublishingState, updating the servicePoolPub database object
        Return True if it has to continue checking, False if finished
        """
        try:
            # Fills up basic data
            userService.unique_id = userServiceInstance.getUniqueId(
            )  # Updates uniqueId
            userService.friendly_name = userServiceInstance.getName(
            )  # And name, both methods can modify serviceInstance, so we save it later
            userService.save(update_fields=['unique_id', 'friendly_name'])

            updater = {
                State.PREPARING: UpdateFromPreparing,
                State.REMOVING: UpdateFromRemoving,
                State.CANCELING: UpdateFromCanceling
            }.get(userService.state, UpdateFromOther)

            logger.debug('Updating %s from %s with updater %s and state %s',
                         userService.friendly_name,
                         State.toString(userService.state), updater, state)

            updater(userService, userServiceInstance).run(state)

        except Exception as e:
            logger.exception('Checking service state')
            log.doLog(userService, log.ERROR, 'Exception: {}'.format(e),
                      log.INTERNAL)
            userService.setState(State.ERROR)
            userService.save(update_fields=['data'])
コード例 #9
0
ファイル: user_service.py プロジェクト: ZenBoy999/openuds
    def requestLogoff(self, userService: UserService) -> None:
        """
        Ask client to logoff user
        """
        proxy = userService.deployed_service.proxy

        url = userService.getCommsUrl()
        if not url:
            logger.error('Can\'t connect with actor (no actor or legacy actor)')
            return

        url += '/logoff'

        try:
            data: typing.Dict = {}
            if proxy:
                r = proxy.doProxyRequest(url=url, data=data, timeout=5)
            else:
                r = requests.post(
                    url,
                    data=json.dumps(data),
                    headers={'content-type': 'application/json'},
                    verify=False,
                    timeout=4
                )
            r = json.loads(r.content)
            logger.debug('Sent logoff to client using %s: %s', url, r)
            # In fact we ignore result right now
        except Exception:
            # logger.info('Logoff requested but service was not listening: %s', e, url)
            pass
コード例 #10
0
ファイル: user_service.py プロジェクト: ZenBoy999/openuds
    def sendScript(self, userService: UserService, script: str, forUser: bool = False) -> None:
        """
        If allowed, send script to user service
        """
        proxy = userService.deployed_service.proxy

        # logger.debug('Senging script: {}'.format(script))
        url = userService.getCommsUrl()
        if not url:
            logger.error('Can\'t connect with actor (no actor or legacy actor)')
            return

        url += '/script'

        try:
            data = {'script': script}
            if forUser:
                data['user'] = '******'  # Just must exists "user" parameter, don't mind value
            if proxy:
                r = proxy.doProxyRequest(url=url, data=data, timeout=5)
            else:
                r = requests.post(
                    url,
                    data=json.dumps(data),
                    headers={'content-type': 'application/json'},
                    verify=False,
                    timeout=5
                )
            r = json.loads(r.content)
            logger.debug('Sent script to client using %s: %s', url, r)
            # In fact we ignore result right now
        except Exception as e:
            logger.error('Exception caught sending script: %s. Check connection on destination machine: %s', e, url)
コード例 #11
0
ファイル: actor_v3.py プロジェクト: krishuang0610/openuds
 def process_login(userService: UserService,
                   username: str) -> typing.Optional[osmanagers.OSManager]:
     osManager: typing.Optional[
         osmanagers.OSManager] = userService.getOsManagerInstance()
     if not userService.in_use:  # If already logged in, do not add a second login (windows does this i.e.)
         osmanagers.OSManager.loggedIn(userService, username)
     return osManager
コード例 #12
0
ファイル: services_usage.py プロジェクト: tanonl/openuds
    def itemToDict(item: UserService) -> typing.Dict[str, typing.Any]:
        """
        Converts an assigned/cached service db item to a dictionary for REST response
        :param item: item to convert
        :param is_cache: If item is from cache or not
        """
        props = item.getProperties()

        if item.user is None:
            owner = ''
            owner_info = {'auth_id': '', 'user_id': ''}
        else:
            owner = item.user.pretty_name
            owner_info = {
                'auth_id': item.user.manager.uuid,
                'user_id': item.user.uuid
            }

        return {
            'id': item.uuid,
            'state_date': item.state_date,
            'creation_date': item.creation_date,
            'unique_id': item.unique_id,
            'friendly_name': item.friendly_name,
            'owner': owner,
            'owner_info': owner_info,
            'service': item.deployed_service.service.name,
            'service_id': item.deployed_service.service.uuid,
            'pool': item.deployed_service.name,
            'pool_id': item.deployed_service.uuid,
            'ip': props.get('ip', _('unknown')),
            'source_host': item.src_hostname,
            'source_ip': item.src_ip,
            'in_use': item.in_use
        }
コード例 #13
0
 def notifyReadyFromOsManager(self, uService, data):
     try:
         ui = uService.getInstance()
         logger.debug('Notifying user service ready state')
         state = ui.notifyReadyFromOsManager(data)
         logger.debug('State: {0}'.format(state))
         uService.updateData(ui)
         if state == State.FINISHED:
             logger.debug('Service is now ready')
             uService.save()
         elif uService.state in (State.USABLE, State.PREPARING):  # We don't want to get active deleting or deleted machines...
             uService.setState(State.PREPARING)
             UserServiceOpChecker.makeUnique(uService, ui, state)
     except Exception as e:
         logger.exception('Unhandled exception on notyfyReady: {}'.format(e))
         UserService.setState(State.ERROR)
         return
コード例 #14
0
    def itemToDict(item: models.UserService,
                   is_cache: bool = False) -> typing.Dict[str, typing.Any]:
        """
        Converts an assigned/cached service db item to a dictionary for REST response
        :param item: item to convert
        :param is_cache: If item is from cache or not
        """
        props = item.getProperties()

        val = {
            'id':
            item.uuid,
            'id_deployed_service':
            item.deployed_service.uuid,
            'unique_id':
            item.unique_id,
            'friendly_name':
            item.friendly_name,
            'state':
            item.state if
            not (props.get('destroy_after') and item.state == State.PREPARING)
            else State.CANCELING,
            'os_state':
            item.os_state,
            'state_date':
            item.state_date,
            'creation_date':
            item.creation_date,
            'revision':
            item.publication and item.publication.revision or '',
            'ip':
            props.get('ip', _('unknown')),
            'actor_version':
            props.get('actor_version', _('unknown')),
        }

        if is_cache:
            val['cache_level'] = item.cache_level
        else:
            if item.user is None:
                owner = ''
                owner_info = {'auth_id': '', 'user_id': ''}
            else:
                owner = item.user.pretty_name
                owner_info = {
                    'auth_id': item.user.manager.uuid,
                    'user_id': item.user.uuid
                }

            val.update({
                'owner': owner,
                'owner_info': owner_info,
                'in_use': item.in_use,
                'in_use_date': item.in_use_date,
                'source_host': item.src_hostname,
                'source_ip': item.src_ip
            })
        return val
コード例 #15
0
ファイル: user_service.py プロジェクト: hanwoody/openuds
    def isReady(self, userService: UserService) -> bool:
        userService.refresh_from_db()
        logger.debug('Checking ready of %s', userService)

        if userService.state != State.USABLE or userService.os_state != State.USABLE:
            logger.debug('State is not usable for %s', userService.name)
            return False

        logger.debug('Service %s is usable, checking it via setReady',
                     userService)
        userServiceInstance = userService.getInstance()
        try:
            state = userServiceInstance.setReady()
        except Exception as e:
            logger.warn('Could not check readyness of %s: %s', userService, e)
            return False

        logger.debug('State: %s', state)

        if state == State.FINISHED:
            userService.updateData(userServiceInstance)
            return True

        userService.setState(State.PREPARING)
        UserServiceOpChecker.makeUnique(userService, userServiceInstance,
                                        state)

        return False
コード例 #16
0
ファイル: connection.py プロジェクト: spofa/openuds
    def serviceList(self):
        # We look for services for this authenticator groups. User is logged in in just 1 authenticator, so his groups must coincide with those assigned to ds
        groups = list(self._user.getGroups())
        availServices = DeployedService.getDeployedServicesForGroups(groups)
        availUserServices = UserService.getUserAssignedServices(self._user)

        # Extract required data to show to user
        services = []
        # Select assigned user services
        for svr in availUserServices:
            # Skip maintenance services...
            trans = []
            for t in svr.transports.all().order_by('priority'):
                if t.validForIp(self._request.ip) and t.getType(
                ).providesConnetionInfo():
                    trans.append({'id': t.uuid, 'name': t.name})

            services.append({
                'id': 'A' + svr.uuid,
                'name': svr['name'],
                'transports': trans,
                'maintenance': svr.isInMaintenance(),
                'in_use': svr.in_use
            })

        logger.debug(services)

        # Now generic user service
        for svr in availServices:
            trans = []
            for t in svr.transports.all().order_by('priority'):
                if t.validForIp(self._request.ip) and t.getType(
                ).providesConnetionInfo():
                    trans.append({'id': t.uuid, 'name': t.name})

            # Locate if user service has any already assigned user service for this
            ads = UserServiceManager.manager().getExistingAssignationForUser(
                svr, self._user)
            if ads is None:
                in_use = False
            else:
                in_use = ads.in_use

            services.append({
                'id': 'F' + svr.uuid,
                'name': svr.name,
                'transports': trans,
                'maintenance': svr.isInMaintenance(),
                'in_use': in_use
            })

        logger.debug('Services: {0}'.format(services))

        services = sorted(services, key=lambda s: s['name'].upper())

        return Connection.result(result=services)
コード例 #17
0
 def notifyReadyFromOsManager(self, uService, data):
     try:
         ui = uService.getInstance()
         logger.debug('Notifying user service ready state')
         state = ui.notifyReadyFromOsManager(data)
         logger.debug('State: {0}'.format(state))
         uService.updateData(ui)
         if state == State.FINISHED:
             logger.debug('Service is now ready')
             uService.save()
         elif uService.state in (
                 State.USABLE, State.PREPARING
         ):  # We don't want to get active deleting or deleted machines...
             uService.setState(State.PREPARING)
             UserServiceOpChecker.makeUnique(uService, ui, state)
     except Exception as e:
         logger.exception(
             'Unhandled exception on notyfyReady: {}'.format(e))
         UserService.setState(State.ERROR)
         return
コード例 #18
0
ファイル: user_service.py プロジェクト: ZenBoy999/openuds
    def checkUuid(self, userService: UserService) ->  bool:
        '''
        Checks if the uuid of the service is the same of our known uuid on DB
        '''
        proxy = userService.deployed_service.proxy

        url = userService.getCommsUrl()

        if not url:
            logger.debug('No uuid to retrieve because agent does not supports notifications')
            return True  # UUid is valid because it is not supported checking it

        version = userService.getProperty('actor_version') or ''
        # Just for 2.0 or newer, previous actors will not support this method.
        # Also externally supported agents will not support this method (as OpenGnsys)
        if '-' in version or version < '2.0.0':
            return True

        url += '/uuid'

        try:
            if proxy:
                r = proxy.doProxyRequest(url=url, timeout=5)
            else:
                r = requests.get(url, verify=False, timeout=5)

            if version >= '3.0.0':  # New type of response: {'result': uuid}
                uuid = r.json()['result']
            else:
                uuid = r.json()

            if uuid != userService.uuid:
                logger.info('The requested machine has uuid %s and the expected was %s', uuid, userService.uuid)
                return False

            logger.debug('Got uuid from machine: %s %s %s', url, uuid, userService.uuid)
            # In fact we ignore result right now
        except Exception as e:
            logger.error('Get uuid failed: %s. Check connection on destination machine: %s', e, url)

        return True
コード例 #19
0
    def moveToLevel(self, cache: UserService, cacheLevel: int) -> None:
        """
        Moves a cache element from one level to another
        @return: cache element
        """
        cache.refresh_from_db()
        logger.debug('Moving cache %s to level %s', cache, cacheLevel)
        cacheInstance = cache.getInstance()
        state = cacheInstance.moveToCache(cacheLevel)
        cache.cache_level = cacheLevel
        cache.save(update_fields=['cache_level'])
        logger.debug('Service State: %a %s %s', State.toString(state), State.toString(cache.state), State.toString(cache.os_state))
        if State.isRuning(state) and cache.isUsable():
            cache.setState(State.PREPARING)

        # Data will be serialized on makeUnique process
        UserServiceOpChecker.makeUnique(cache, cacheInstance, state)
コード例 #20
0
 def notifyReadyFromOsManager(self, userService: UserService, data: typing.Any) -> None:
     try:
         userServiceInstance = userService.getInstance()
         logger.debug('Notifying user service ready state')
         state = userServiceInstance.notifyReadyFromOsManager(data)
         logger.debug('State: %s', state)
         if state == State.FINISHED:
             userService.updateData(userServiceInstance)
             logger.debug('Service is now ready')
         elif userService.state in (State.USABLE, State.PREPARING):  # We don't want to get active deleting or deleted machines...
             userService.setState(State.PREPARING)
             UserServiceOpChecker.makeUnique(userService, userServiceInstance, state)
         userService.save(update_fields=['os_state'])
     except Exception as e:
         logger.exception('Unhandled exception on notyfyReady: %s', e)
         userService.setState(State.ERROR)
         return
コード例 #21
0
ファイル: connection.py プロジェクト: aiminickwong/openuds
    def serviceList(self):
        # We look for services for this authenticator groups. User is logged in in just 1 authenticator, so his groups must coincide with those assigned to ds
        groups = list(self._user.getGroups())
        availServices = DeployedService.getDeployedServicesForGroups(groups)
        availUserServices = UserService.getUserAssignedServices(self._user)

        # Extract required data to show to user
        services = []
        # Select assigned user services
        for svr in availUserServices:
            # Skip maintenance services...
            trans = []
            for t in svr.transports.all().order_by('priority'):
                typeTrans = t.getType()
                if t.validForIp(self._request.ip) and t.getType().providesConnetionInfo():
                    trans.append({'id': t.uuid, 'name': t.name, 'needsJava': t.getType().needsJava})
            services.append({'id': 'A' + svr.uuid,
                             'name': svr['name'],
                             'transports': trans,
                             'maintenance': svr.deployed_service.service.provider.maintenance_mode,
                             'in_use': svr.in_use})

        logger.debug(services)

        # Now generic user service
        for svr in availServices:
            trans = []
            for t in svr.transports.all().order_by('priority'):
                if t.validForIp(self._request.ip) and t.getType().providesConnetionInfo():
                    typeTrans = t.getType()
                    trans.append({'id': t.uuid, 'name': t.name, 'needsJava': typeTrans.needsJava})

            # Locate if user service has any already assigned user service for this
            ads = UserServiceManager.manager().getExistingAssignationForUser(svr, self._user)
            if ads is None:
                in_use = False
            else:
                in_use = ads.in_use

            services.append({'id': 'F' + svr.uuid,
                             'name': svr.name,
                             'transports': trans,
                             'maintenance': svr.service.provider.maintenance_mode,
                             'in_use': in_use})

        logger.debug('Services: {0}'.format(services))

        services = sorted(services, key=lambda s: s['name'].upper())

        return Connection.result(result=services)
コード例 #22
0
ファイル: index.py プロジェクト: borzel/openuds
def index(request):
    """
    Renders the main page.
    :param request: http request
    """
    if request.session.get('ticket') == '1':
        return webLogout(request)

    # Session data
    os = request.os

    # We look for services for this authenticator groups. User is logged in in just 1 authenticator, so his groups must coincide with those assigned to ds
    groups = list(request.user.getGroups())
    availServices = DeployedService.getDeployedServicesForGroups(groups)
    availUserServices = UserService.getUserAssignedServices(request.user)

    # Information for administrators
    nets = ''
    validTrans = ''

    logger.debug('OS: {0}'.format(os['OS']))

    if request.user.isStaff():
        nets = ','.join([n.name for n in Network.networksFor(request.ip)])
        tt = []
        for t in Transport.objects.all():
            if t.validForIp(request.ip):
                tt.append(t.name)
        validTrans = ','.join(tt)

    # Extract required data to show to user
    services = []
    # Select assigned user services (manually assigned)
    for svr in availUserServices:
        trans = []
        for t in svr.transports.all().order_by('priority'):
            typeTrans = t.getType()
            if t.validForIp(request.ip) and typeTrans.supportsOs(
                    os['OS']) and t.validForOs(os['OS']):
                if typeTrans.ownLink is True:
                    link = reverse('TransportOwnLink',
                                   args=('A' + svr.uuid, t.uuid))
                else:
                    link = html.udsAccessLink(request, 'A' + svr.uuid, t.uuid)
                trans.append({'id': t.uuid, 'name': t.name, 'link': link})

        servicePool = svr.deployed_service

        if servicePool.image is not None:
            imageId = servicePool.image.uuid
        else:
            imageId = 'x'  # Invalid

        # Extract app group
        group = servicePool.servicesPoolGroup if servicePool.servicesPoolGroup is not None else ServicesPoolGroup.default(
        ).as_dict

        services.append({
            'id': 'A' + svr.uuid,
            'name': servicePool.name,
            'visual_name': servicePool.visual_name,
            'description': servicePool.comments,
            'group': group,
            'transports': trans,
            'imageId': imageId,
            'show_transports': servicePool.show_transports,
            'allow_users_remove': servicePool.allow_users_remove,
            'allow_users_reset': servicePool.allow_users_reset,
            'maintenance': servicePool.isInMaintenance(),
            'not_accesible': not servicePool.isAccessAllowed(),
            'in_use': svr.in_use,
            'to_be_replaced':
            False,  # Manually assigned will not be autoremoved never
            'comments': servicePool.comments,
        })

    logger.debug(services)

    # Now generic user service
    for svr in availServices:
        trans = []
        for t in svr.transports.all().order_by('priority'):
            typeTrans = t.getType()
            if typeTrans is None:  # This may happen if we "remove" a transport type but we have a transport of that kind on DB
                continue
            if t.validForIp(request.ip) and typeTrans.supportsOs(
                    os['OS']) and t.validForOs(os['OS']):
                if typeTrans.ownLink is True:
                    link = reverse('TransportOwnLink',
                                   args=('F' + svr.uuid, t.uuid))
                else:
                    link = html.udsAccessLink(request, 'F' + svr.uuid, t.uuid)
                trans.append({'id': t.uuid, 'name': t.name, 'link': link})
        if svr.image is not None:
            imageId = svr.image.uuid
        else:
            imageId = 'x'

        # Locate if user service has any already assigned user service for this
        ads = UserServiceManager.manager().getExistingAssignationForUser(
            svr, request.user)
        if ads is None:
            in_use = False
        else:
            in_use = ads.in_use

        group = svr.servicesPoolGroup.as_dict if svr.servicesPoolGroup is not None else ServicesPoolGroup.default(
        ).as_dict

        tbr = svr.toBeReplaced()
        if tbr is not None:
            tbr = formats.date_format(tbr, "SHORT_DATETIME_FORMAT")
            tbrt = ugettext(
                'This service is about to be replaced by a new version. Please, close the session before {} and save all your work to avoid loosing it.'
            ).format(tbr)
        else:
            tbrt = ''

        services.append({
            'id': 'F' + svr.uuid,
            'name': svr.name,
            'visual_name': svr.visual_name,
            'description': svr.comments,
            'group': group,
            'transports': trans,
            'imageId': imageId,
            'show_transports': svr.show_transports,
            'allow_users_remove': svr.allow_users_remove,
            'allow_users_reset': svr.allow_users_reset,
            'maintenance': svr.isInMaintenance(),
            'not_accesible': not svr.isAccessAllowed(),
            'in_use': in_use,
            'to_be_replaced': tbr,
            'to_be_replaced_text': tbrt,
            'comments': svr.comments,
        })

    logger.debug('Services: {0}'.format(services))

    services = sorted(services, key=lambda s: s['name'].upper())

    autorun = False
    if len(services) == 1 and GlobalConfig.AUTORUN_SERVICE.getBool(
            True) and len(services[0]['transports']) > 0:
        if request.session.get('autorunDone', '0') == '0':
            request.session['autorunDone'] = '1'
            autorun = True
            # return redirect('uds.web.views.service', idService=services[0]['id'], idTransport=services[0]['transports'][0]['id'])

    # List of services groups
    allGroups = [
        v for v in sorted([ser['group'] for ser in services],
                          key=lambda s: s['priority'])
    ]
    # Now remove duplicates
    groups = []
    already = []
    for g in allGroups:
        if g['name'] not in already:
            already.append(g['name'])
            groups.append(g)

    logger.debug('Groups: {}'.format(groups))

    response = render(
        request, theme.template('index.html'), {
            'groups': groups,
            'services': services,
            'ip': request.ip,
            'nets': nets,
            'transports': validTrans,
            'autorun': autorun
        })
    return response
コード例 #23
0
def index(request):
    '''
    Renders the main page.
    :param request: http request
    '''
    # Session data
    os = request.os

    # We look for services for this authenticator groups. User is logged in in just 1 authenticator, so his groups must coincide with those assigned to ds
    groups = list(request.user.getGroups())
    availServices = DeployedService.getDeployedServicesForGroups(groups)
    availUserServices = UserService.getUserAssignedServices(request.user)

    # Information for administrators
    nets = ''
    validTrans = ''

    logger.debug('OS: {0}'.format(os['OS']))

    if request.user.isStaff():
        nets = ','.join([n.name for n in Network.networksFor(request.ip)])
        tt = []
        for t in Transport.objects.all():
            if t.validForIp(request.ip):
                tt.append(t.name)
        validTrans = ','.join(tt)

    # Extract required data to show to user
    services = []
    # Select assigned user services
    for svr in availUserServices:
        trans = []
        for t in svr.transports.all().order_by('priority'):
            typeTrans = t.getType()
            if t.validForIp(request.ip) and typeTrans.supportsOs(os['OS']):
                if typeTrans.ownLink is True:
                    link = reverse('TransportOwnLink',
                                   args=('A' + svr.uuid, t.uuid))
                else:
                    link = html.udsAccessLink(request, 'A' + svr.uuid, t.uuid)
                trans.append({'id': t.uuid, 'name': t.name, 'link': link})
        if svr.deployed_service.image is not None:
            imageId = svr.deployed_service.image.uuid
        else:
            imageId = 'x'  # Invalid

        services.append({
            'id': 'A' + svr.uuid,
            'name': svr['name'],
            'transports': trans,
            'imageId': imageId,
            'show_transports': svr.deployed_service.show_transports,
            'maintenance':
            svr.deployed_service.service.provider.maintenance_mode,
            'in_use': svr.in_use,
        })

    logger.debug(services)

    # Now generic user service
    for svr in availServices:
        # Generate ticket

        trans = []
        for t in svr.transports.all().order_by('priority'):
            typeTrans = t.getType()
            if t.validForIp(request.ip) and typeTrans.supportsOs(os['OS']):
                if typeTrans.ownLink is True:
                    link = reverse('TransportOwnLink',
                                   args=('F' + svr.uuid, t.uuid))
                else:
                    link = html.udsAccessLink(request, 'F' + svr.uuid, t.uuid)
                trans.append({'id': t.uuid, 'name': t.name, 'link': link})
        if svr.image is not None:
            imageId = svr.image.uuid
        else:
            imageId = 'x'

        # Locate if user service has any already assigned user service for this
        ads = UserServiceManager.manager().getExistingAssignationForUser(
            svr, request.user)
        if ads is None:
            in_use = False
        else:
            in_use = ads.in_use

        services.append({
            'id': 'F' + svr.uuid,
            'name': svr.name,
            'transports': trans,
            'imageId': imageId,
            'show_transports': svr.show_transports,
            'maintenance': svr.service.provider.maintenance_mode,
            'in_use': in_use,
        })

    logger.debug('Services: {0}'.format(services))

    services = sorted(services, key=lambda s: s['name'].upper())

    if len(services) == 1 and GlobalConfig.AUTORUN_SERVICE.get(
            True) == '1' and len(services[0]['transports']) > 0:
        if request.session.get('autorunDone', '0') == '0':
            request.session['autorunDone'] = '1'
            # TODO: Make this to redirect to uds link directly
            return redirect('uds.web.views.service',
                            idService=services[0]['id'],
                            idTransport=services[0]['transports'][0]['id'])

    response = render_to_response(theme.template('index.html'), {
        'services': services,
        'ip': request.ip,
        'nets': nets,
        'transports': validTrans,
    },
                                  context_instance=RequestContext(request))
    return response
コード例 #24
0
ファイル: connection.py プロジェクト: glyptodon/openuds
    def serviceList(self):
        # We look for services for this authenticator groups. User is logged in in just 1 authenticator, so his groups must coincide with those assigned to ds
        groups = list(self._user.getGroups())
        availServices = DeployedService.getDeployedServicesForGroups(groups)
        availUserServices = UserService.getUserAssignedServices(self._user)

        # Extract required data to show to user
        services = []
        # Select assigned user services
        for svr in availUserServices:
            # Skip maintenance services...
            trans = []
            for t in svr.transports.all().order_by('priority'):
                if t.validForIp(self._request.ip) and t.getType().providesConnetionInfo():
                    trans.append({'id': t.uuid, 'name': t.name})

            servicePool = svr.deployed_service

            services.append({'id': 'A' + svr.uuid,
                             'name': servicePool.name,
                             'description': servicePool.comments,
                             'visual_name': servicePool.visual_name,
                             'group': servicePool.servicesPoolGroup if servicePool.servicesPoolGroup is not None else ServicesPoolGroup.default().as_dict,
                             'thumb': servicePool.image.thumb64 if servicePool.image is not None else DEFAULT_THUMB_BASE64,
                             'show_transports': servicePool.show_transports,
                             'allow_users_remove': servicePool.allow_users_remove,
                             'maintenance': servicePool.isInMaintenance(),
                             'not_accesible': not servicePool.isAccessAllowed(),
                             'to_be_replaced': False,  # Manually assigned will not be autoremoved never
                             'transports': trans,
                             'maintenance': servicePool.isInMaintenance(),
                             'in_use': servicePool.in_use})

        logger.debug(services)

        # Now generic user service
        for servicePool in availServices:
            trans = []
            for t in servicePool.transports.all().order_by('priority'):
                if t.validForIp(self._request.ip) and t.getType().providesConnetionInfo():
                    trans.append({'id': t.uuid, 'name': t.name})

            # Locate if user service has any already assigned user service for this
            ads = userServiceManager().getExistingAssignationForUser(servicePool, self._user)
            if ads is None:
                in_use = False
            else:
                in_use = ads.in_use

            services.append({'id': 'F' + servicePool.uuid,
                             'name': servicePool.name,
                             'description': servicePool.comments,
                             'visual_name': servicePool.visual_name,
                             'group': servicePool.servicesPoolGroup if servicePool.servicesPoolGroup is not None else ServicesPoolGroup.default().as_dict,
                             'thumb': servicePool.image.thumb64 if servicePool.image is not None else DEFAULT_THUMB_BASE64,
                             'show_transports': servicePool.show_transports,
                             'allow_users_remove': servicePool.allow_users_remove,
                             'maintenance': servicePool.isInMaintenance(),
                             'not_accesible': not servicePool.isAccessAllowed(),
                             'to_be_replaced': servicePool.toBeReplaced(),
                             'transports': trans,
                             'maintenance': servicePool.isInMaintenance(),
                             'in_use': in_use})

        logger.debug('Services: {0}'.format(services))

        services = sorted(services, key=lambda s: s['name'].upper())

        return Connection.result(result=services)
コード例 #25
0
ファイル: index.py プロジェクト: glyptodon/openuds
def index(request):
    """
    Renders the main page.
    :param request: http request
    """
    if request.session.get('ticket') == '1':
        return webLogout(request)

    # Session data
    os = request.os

    # We look for services for this authenticator groups. User is logged in in just 1 authenticator, so his groups must coincide with those assigned to ds
    groups = list(request.user.getGroups())
    availServices = DeployedService.getDeployedServicesForGroups(groups)
    availUserServices = UserService.getUserAssignedServices(request.user)

    # Information for administrators
    nets = ''
    validTrans = ''

    logger.debug('OS: {0}'.format(os['OS']))

    if request.user.isStaff():
        nets = ','.join([n.name for n in Network.networksFor(request.ip)])
        tt = []
        for t in Transport.objects.all():
            if t.validForIp(request.ip):
                tt.append(t.name)
        validTrans = ','.join(tt)

    # Extract required data to show to user
    services = []
    # Select assigned user services (manually assigned)
    for svr in availUserServices:
        trans = []
        for t in svr.transports.all().order_by('priority'):
            typeTrans = t.getType()
            if t.validForIp(request.ip) and typeTrans.supportsOs(os['OS']) and t.validForOs(os['OS']):
                if typeTrans.ownLink is True:
                    link = reverse('TransportOwnLink', args=('A' + svr.uuid, t.uuid))
                else:
                    link = html.udsAccessLink(request, 'A' + svr.uuid, t.uuid)
                trans.append(
                    {
                        'id': t.uuid,
                        'name': t.name,
                        'link': link
                    }
                )

        servicePool = svr.deployed_service

        if servicePool.image is not None:
            imageId = servicePool.image.uuid
        else:
            imageId = 'x'  # Invalid

        # Extract app group
        group = servicePool.servicesPoolGroup if servicePool.servicesPoolGroup is not None else ServicesPoolGroup.default().as_dict

        services.append({
            'id': 'A' + svr.uuid,
            'name': servicePool.name,
            'visual_name': servicePool.visual_name,
            'description': servicePool.comments,
            'group': group,
            'transports': trans,
            'imageId': imageId,
            'show_transports': servicePool.show_transports,
            'allow_users_remove': servicePool.allow_users_remove,
            'maintenance': servicePool.isInMaintenance(),
            'not_accesible': not servicePool.isAccessAllowed(),
            'in_use': svr.in_use,
            'to_be_replaced': False,  # Manually assigned will not be autoremoved never
            'comments': servicePool.comments,
        })

    logger.debug(services)

    # Now generic user service
    for svr in availServices:
        trans = []
        for t in svr.transports.all().order_by('priority'):
            typeTrans = t.getType()
            if typeTrans is None:  # This may happen if we "remove" a transport type but we have a transport of that kind on DB
                continue
            if t.validForIp(request.ip) and typeTrans.supportsOs(os['OS']) and t.validForOs(os['OS']):
                if typeTrans.ownLink is True:
                    link = reverse('TransportOwnLink', args=('F' + svr.uuid, t.uuid))
                else:
                    link = html.udsAccessLink(request, 'F' + svr.uuid, t.uuid)
                trans.append(
                    {
                        'id': t.uuid,
                        'name': t.name,
                        'link': link
                    }
                )
        if svr.image is not None:
            imageId = svr.image.uuid
        else:
            imageId = 'x'

        # Locate if user service has any already assigned user service for this
        ads = UserServiceManager.manager().getExistingAssignationForUser(svr, request.user)
        if ads is None:
            in_use = False
        else:
            in_use = ads.in_use

        group = svr.servicesPoolGroup.as_dict if svr.servicesPoolGroup is not None else ServicesPoolGroup.default().as_dict

        tbr = svr.toBeReplaced()
        if tbr is not None:
            tbr = formats.date_format(tbr, "SHORT_DATETIME_FORMAT")
            tbrt = ugettext('This service is about to be replaced by a new version. Please, close the session before {} and save all your work to avoid loosing it.').format(tbr)
        else:
            tbrt = ''

        services.append({
            'id': 'F' + svr.uuid,
            'name': svr.name,
            'visual_name': svr.visual_name,
            'description': svr.comments,
            'group': group,
            'transports': trans,
            'imageId': imageId,
            'show_transports': svr.show_transports,
            'allow_users_remove': svr.allow_users_remove,
            'maintenance': svr.isInMaintenance(),
            'not_accesible': not svr.isAccessAllowed(),
            'in_use': in_use,
            'to_be_replaced': tbr,
            'to_be_replaced_text': tbrt,
            'comments': svr.comments,
        })

    logger.debug('Services: {0}'.format(services))

    services = sorted(services, key=lambda s: s['name'].upper())

    autorun = False
    if len(services) == 1 and GlobalConfig.AUTORUN_SERVICE.getBool(True) and len(services[0]['transports']) > 0:
        if request.session.get('autorunDone', '0') == '0':
            request.session['autorunDone'] = '1'
            autorun = True
            # return redirect('uds.web.views.service', idService=services[0]['id'], idTransport=services[0]['transports'][0]['id'])

    # List of services groups
    allGroups = [v for v in sorted([ser['group'] for ser in services], key=lambda s: s['priority'])]
    # Now remove duplicates
    groups = []
    already = []
    for g in allGroups:
        if g['name'] not in already:
            already.append(g['name'])
            groups.append(g)

    logger.debug('Groups: {}'.format(groups))

    response = render(
        request,
        theme.template('index.html'),
        {
            'groups': groups,
            'services': services,
            'ip': request.ip,
            'nets': nets,
            'transports': validTrans,
            'autorun': autorun
        }
    )
    return response
コード例 #26
0
ファイル: opchecker.py プロジェクト: tanonl/openuds
 def __init__(self,
              userService: UserService,
              userServiceInstance: typing.Optional[UserDeployment] = None):
     self.userService = userService
     self.userServiceInstance = userServiceInstance if userServiceInstance is not None else userService.getInstance(
     )
コード例 #27
0
ファイル: index.py プロジェクト: aiminickwong/openuds
def index(request):
    '''
    Renders the main page.
    :param request: http request
    '''
    # Session data
    os = request.os

    # We look for services for this authenticator groups. User is logged in in just 1 authenticator, so his groups must coincide with those assigned to ds
    groups = list(request.user.getGroups())
    availServices = DeployedService.getDeployedServicesForGroups(groups)
    availUserServices = UserService.getUserAssignedServices(request.user)

    # Information for administrators
    nets = ''
    validTrans = ''

    logger.debug('OS: {0}'.format(os['OS']))

    if request.user.isStaff():
        nets = ','.join([n.name for n in Network.networksFor(request.ip)])
        tt = []
        for t in Transport.objects.all():
            if t.validForIp(request.ip):
                tt.append(t.name)
        validTrans = ','.join(tt)

    # Extract required data to show to user
    services = []
    # Select assigned user services
    for svr in availUserServices:
        trans = []
        for t in svr.transports.all().order_by('priority'):
            typeTrans = t.getType()
            if t.validForIp(request.ip) and typeTrans.supportsOs(os['OS']):
                if typeTrans.ownLink is True:
                    link = reverse('TransportOwnLink', args=('A' + svr.uuid, t.uuid))
                else:
                    link = html.udsAccessLink(request, 'A' + svr.uuid, t.uuid)
                trans.append(
                    {
                        'id': t.uuid,
                        'name': t.name,
                        'link': link
                    }
                )
        if svr.deployed_service.image is not None:
            imageId = svr.deployed_service.image.uuid
        else:
            imageId = 'x'  # Invalid

        services.append({
            'id': 'A' + svr.uuid,
            'name': svr['name'],
            'transports': trans,
            'imageId': imageId,
            'show_transports': svr.deployed_service.show_transports,
            'maintenance': svr.deployed_service.service.provider.maintenance_mode,
            'in_use': svr.in_use,
        })

    logger.debug(services)

    # Now generic user service
    for svr in availServices:
        # Generate ticket

        trans = []
        for t in svr.transports.all().order_by('priority'):
            typeTrans = t.getType()
            if t.validForIp(request.ip) and typeTrans.supportsOs(os['OS']):
                if typeTrans.ownLink is True:
                    link = reverse('TransportOwnLink', args=('F' + svr.uuid, t.uuid))
                else:
                    link = html.udsAccessLink(request, 'F' + svr.uuid, t.uuid)
                trans.append(
                    {
                        'id': t.uuid,
                        'name': t.name,
                        'link': link
                    }
                )
        if svr.image is not None:
            imageId = svr.image.uuid
        else:
            imageId = 'x'

        # Locate if user service has any already assigned user service for this
        ads = UserServiceManager.manager().getExistingAssignationForUser(svr, request.user)
        if ads is None:
            in_use = False
        else:
            in_use = ads.in_use

        services.append({
            'id': 'F' + svr.uuid,
            'name': svr.name,
            'transports': trans,
            'imageId': imageId,
            'show_transports': svr.show_transports,
            'maintenance': svr.service.provider.maintenance_mode,
            'in_use': in_use,
        })

    logger.debug('Services: {0}'.format(services))

    services = sorted(services, key=lambda s: s['name'].upper())

    if len(services) == 1 and GlobalConfig.AUTORUN_SERVICE.get(True) == '1' and len(services[0]['transports']) > 0:
        if request.session.get('autorunDone', '0') == '0':
            request.session['autorunDone'] = '1'
            # TODO: Make this to redirect to uds link directly
            return redirect('uds.web.views.service', idService=services[0]['id'], idTransport=services[0]['transports'][0]['id'])

    response = render_to_response(
        theme.template('index.html'),
        {
            'services': services,
            'ip': request.ip,
            'nets': nets,
            'transports': validTrans,
        },
        context_instance=RequestContext(request)
    )
    return response
コード例 #28
0
ファイル: connection.py プロジェクト: karthik-arjunan/testuds
    def serviceList(self):
        # We look for services for this authenticator groups. User is logged in in just 1 authenticator, so his groups must coincide with those assigned to ds
        groups = list(self._user.getGroups())
        availServices = DeployedService.getDeployedServicesForGroups(groups)
        availUserServices = UserService.getUserAssignedServices(self._user)

        # Extract required data to show to user
        services = []
        # Select assigned user services
        for svr in availUserServices:
            # Skip maintenance services...
            trans = []
            for t in svr.transports.all().order_by('priority'):
                if t.validForIp(self._request.ip) and t.getType().providesConnetionInfo():
                    trans.append({'id': t.uuid, 'name': t.name})

            servicePool = svr.deployed_service

            services.append({'id': 'A' + svr.uuid,
                             'name': servicePool.name,
                             'description': servicePool.comments,
                             'visual_name': servicePool.visual_name,
                             'group': servicePool.servicesPoolGroup if servicePool.servicesPoolGroup is not None else ServicesPoolGroup.default().as_dict,
                             'thumb': servicePool.image.thumb64 if servicePool.image is not None else DEFAULT_THUMB_BASE64,
                             'show_transports': servicePool.show_transports,
                             'allow_users_remove': servicePool.allow_users_remove,
                             'maintenance': servicePool.isInMaintenance(),
                             'not_accesible': not servicePool.isAccessAllowed(),
                             'to_be_replaced': False,  # Manually assigned will not be autoremoved never
                             'transports': trans,
                             'in_use': svr.in_use})

        logger.debug(services)

        # Now generic user service
        for servicePool in availServices:
            trans = []
            for t in servicePool.transports.all().order_by('priority'):
                if t.validForIp(self._request.ip) and t.getType().providesConnetionInfo():
                    trans.append({'id': t.uuid, 'name': t.name})

            # Locate if user service has any already assigned user service for this
            ads = userServiceManager().getExistingAssignationForUser(servicePool, self._user)
            if ads is None:
                in_use = False
            else:
                in_use = ads.in_use

            services.append({'id': 'F' + servicePool.uuid,
                             'name': servicePool.name,
                             'description': servicePool.comments,
                             'visual_name': servicePool.visual_name,
                             'group': servicePool.servicesPoolGroup if servicePool.servicesPoolGroup is not None else ServicesPoolGroup.default().as_dict,
                             'thumb': servicePool.image.thumb64 if servicePool.image is not None else DEFAULT_THUMB_BASE64,
                             'show_transports': servicePool.show_transports,
                             'allow_users_remove': servicePool.allow_users_remove,
                             'maintenance': servicePool.isInMaintenance(),
                             'not_accesible': not servicePool.isAccessAllowed(),
                             'to_be_replaced': servicePool.toBeReplaced(),
                             'transports': trans,
                             'in_use': in_use})

        logger.debug('Services: {0}'.format(services))

        services = sorted(services, key=lambda s: s['name'].upper())

        return Connection.result(result=services)
コード例 #29
0
ファイル: actor_v3.py プロジェクト: krishuang0610/openuds
 def setCommsUrl(userService: UserService, ip: str, port: int, secret: str):
     userService.setCommsUrl('https://{}:{}/actor/{}'.format(
         ip, port, secret))