import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * Either the element is removed from the cache
 * or it's not found in the cache and is already removed.
 * Thus the result of this op would always be true.
 */
@Override
public boolean deleteSingleTicket(final String ticketId) {
    final Ticket ticket = getTicket(ticketId);
    
    if (ticket == null) {
        logger.debug("Ticket {} cannot be retrieved from the cache", ticketId);
        return true;
    }

    if (this.ticketGrantingTicketsCache.remove(ticket.getId())) {
        logger.debug("Ticket {} is removed", ticket.getId());
    }
    if (this.serviceTicketsCache.remove(ticket.getId())) {
        logger.debug("Ticket {} is removed", ticket.getId());
    }
    return true;
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
/**
 * Determines whether the TGT in the flow request context is valid.
 *
 * @param requestContext Flow request context.
 *
 * @throws Exception in case ticket cannot be retrieved from the service layer
 * @return {@link #NOT_EXISTS}, {@link #INVALID}, or {@link #VALID}.
 */
@Override
protected Event doExecute(final RequestContext requestContext) throws Exception {
    final String tgtId = WebUtils.getTicketGrantingTicketId(requestContext);
    if (!StringUtils.hasText(tgtId)) {
        return new Event(this, NOT_EXISTS);
    }

    String eventId = INVALID;
    try {
        final Ticket ticket = this.centralAuthenticationService.getTicket(tgtId, Ticket.class);
        if (ticket != null && !ticket.isExpired()) {
            eventId = VALID;
        }
    } catch (final AbstractTicketException e) {
        logger.trace("Could not retrieve ticket id {} from registry.", e);
    }
    return new Event(this,  eventId);
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
/**
 * {@inheritDoc}
 *
 * Note:
 * Synchronization on ticket object in case of cache based registry doesn't serialize
 * access to critical section. The reason is that cache pulls serialized data and
 * builds new object, most likely for each pull. Is this synchronization needed here?
 */
@Timed(name = "GET_TICKET_TIMER")
@Metered(name = "GET_TICKET_METER")
@Counted(name="GET_TICKET_COUNTER", monotonic=true)
@Override
public <T extends Ticket> T getTicket(final String ticketId, final Class<? extends Ticket> clazz)
        throws InvalidTicketException {
    Assert.notNull(ticketId, "ticketId cannot be null");
    final Ticket ticket = this.ticketRegistry.getTicket(ticketId, clazz);

    if (ticket == null) {
        logger.debug("Ticket [{}] by type [{}] cannot be found in the ticket registry.", ticketId, clazz.getSimpleName());
        throw new InvalidTicketException(ticketId);
    }

    if (ticket instanceof TicketGrantingTicket) {
        synchronized (ticket) {
            if (ticket.isExpired()) {
                this.ticketRegistry.deleteTicket(ticketId);
                logger.debug("Ticket [{}] has expired and is now deleted from the ticket registry.", ticketId);
                throw new InvalidTicketException(ticketId);
            }
        }
    }
    return (T) ticket;
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
protected String resolveFromInternal(final JoinPoint joinPoint) {
    final Object arg1 = joinPoint.getArgs()[0];
    if (arg1 instanceof Credential) {
       return arg1.toString();
    } else if (arg1 instanceof String) {
        final Ticket ticket = this.ticketRegistry.getTicket((String) arg1);
        if (ticket instanceof ServiceTicket) {
            final ServiceTicket serviceTicket = (ServiceTicket) ticket;
            return serviceTicket.getGrantingTicket().getAuthentication().getPrincipal().getId();
        } else if (ticket instanceof TicketGrantingTicket) {
            final TicketGrantingTicket tgt = (TicketGrantingTicket) ticket;
            return tgt.getAuthentication().getPrincipal().getId();
        }
    } else {
        final SecurityContext securityContext = SecurityContextHolder.getContext();
        if (securityContext != null) {
            final Authentication authentication = securityContext.getAuthentication();

            if (authentication != null) {
                return ((UserDetails) authentication.getPrincipal()).getUsername();
            }
        }
    }
    return UNKNOWN_USER;
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
/**
 * Decode ticket.
 *
 * @param result the result
 * @return the ticket
 */
protected Ticket decodeTicket(final Ticket result) {
    if (this.cipherExecutor == null) {
        logger.trace("Ticket encryption is not enabled. Falling back to default behavior");
        return result;
    }

    if (result == null) {
        return result;
    }

    logger.info("Attempting to decode {}", result);
    final EncodedTicket encodedTicket = (EncodedTicket) result;

    final Ticket ticket = CompressionUtils.decodeAndSerializeObject(
            encodedTicket.getEncoded(), this.cipherExecutor, Ticket.class);
    logger.info("Decoded {}",  ticket);
    return ticket;
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
@Transactional(readOnly = false)
public boolean deleteTicket(final String ticketId) {
    final Ticket ticket = getRawTicket(ticketId);

    if (ticket == null) {
        return false;
    }

    if (ticket instanceof ServiceTicket) {
        removeTicket(ticket);
        logger.debug("Deleted ticket [{}] from the registry.", ticket);
        return true;
    }

    deleteTicketAndChildren(ticket);
    logger.debug("Deleted ticket [{}] and its children from the registry.", ticket);
    return true;
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
@Override
public Ticket getTicket(final String ticketId) {
    try {
        final SerializableDocument document = couchbase.bucket().get(ticketId, SerializableDocument.class);
        if (document != null) {
            final Ticket t = (Ticket) document.content();
            logger.debug("Got ticket {} from registry.", t);
            return getProxiedTicketInstance(t);
        }
        logger.debug("Ticket {} not found in registry.", ticketId);
        return null;
    } catch (final Exception e) {
        logger.error("Failed fetching {}: {}", ticketId, e);
        return null;
    }
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
@Override
public boolean deleteTicket(final String ticketId) {
    final Ticket ticket = getRawTicket(ticketId);

    if (ticket == null) {
        return false;
    }

    if (ticket instanceof ServiceTicket) {
        removeTicket(ticket);
        logger.debug("Deleted ticket [{}] from the registry.", ticket);
        return true;
    }

    deleteTicketAndChildren(ticket);
    logger.debug("Deleted ticket [{}] and its children from the registry.", ticket);
    return true;
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
@Override
public Ticket getTicket(final String ticketIdToGet) {
    final String ticketId = encodeTicketId(ticketIdToGet);
    if (ticketId == null) {
        return null;
    }

    Ticket ticket = this.serviceTicketsCache.get(ticketId);
    if (ticket == null) {
        ticket = this.ticketGrantingTicketsCache.get(ticketId);
    }
    if (ticket == null) {
        logger.debug("No ticket by id [{}] is found in the registry", ticketId);
        return null;
    }

    final Ticket proxiedTicket = decodeTicket(ticket);
    ticket = getProxiedTicketInstance(proxiedTicket);
    return ticket;
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
/**
 * Gets sso sessions.
 *
 * @return the sso sessions
 */
private Collection<Map<String, Object>> getSsoSessions() {
    final List<Map<String, Object>> activeSessions = new ArrayList<Map<String, Object>>();

    for(final Ticket ticket : getNonExpiredTicketGrantingTickets()) {
        final TicketGrantingTicket tgt = (TicketGrantingTicket) ticket;

        final Map<String, Object> sso = new HashMap<>(SsoSessionAttributeKeys.values().length);
        sso.put(SsoSessionAttributeKeys.AUTHENTICATED_PRINCIPAL.toString(), tgt.getAuthentication().getPrincipal().getId());
        sso.put(SsoSessionAttributeKeys.AUTHENTICATION_DATE.toString(), tgt.getAuthentication().getAuthenticationDate());
        sso.put(SsoSessionAttributeKeys.NUMBER_OF_USES.toString(), tgt.getCountOfUses());
        if (this.includeTicketGrantingTicketId) {
            sso.put(SsoSessionAttributeKeys.TICKET_GRANTING_TICKET.toString(), tgt.getId());
        }

        activeSessions.add(Collections.unmodifiableMap(sso));
    }
    return Collections.unmodifiableCollection(activeSessions);
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
Ticket getTicketInTransaction(final String ticketId) {
    return new TransactionTemplate(txManager).execute(new TransactionCallback<Ticket>() {
        @Override
        public Ticket doInTransaction(final TransactionStatus status) {
            return jpaTicketRegistry.getTicket(ticketId);
        }
    });
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * @throws IllegalArgumentException if class is null.
 * @throws ClassCastException if class does not match requested ticket
 * class.
 * @return specified ticket from the registry
 */
@Override
public final <T extends Ticket> T getTicket(final String ticketId, final Class<? extends Ticket> clazz) {
    Assert.notNull(clazz, "clazz cannot be null");

    final Ticket ticket = this.getTicket(ticketId);

    if (ticket == null) {
        return null;
    }

    if (!clazz.isAssignableFrom(ticket.getClass())) {
        throw new ClassCastException("Ticket [" + ticket.getId()
            + " is of type " + ticket.getClass()
            + " when we were expecting " + clazz);
    }

    return (T) ticket;
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
/**
 * Gets the timeout value for the ticket.
 *
 * @param t the t
 * @return the timeout
 */
private int getTimeout(final Ticket t) {
    if (t instanceof TicketGrantingTicket) {
        return this.tgtTimeout;
    } else if (t instanceof ServiceTicket) {
        return this.stTimeout;
    }
    throw new IllegalArgumentException("Invalid ticket type");
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
@Override
public int serviceTicketCount() {
    int count = 0;
    for (final Ticket t : this.cache.values()) {
        if (t instanceof ServiceTicket) {
            count++;
        }
    }
    return count;
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
@Override
public Ticket getTicket(final String ticketId) {
    if (ticketId == null) {
        return null;
    }

    logger.debug("Attempting to retrieve ticket [{}]", ticketId);
    final Ticket ticket = this.cache.get(ticketId);

    if (ticket != null) {
        logger.debug("Ticket [{}] found in registry.", ticketId);
    }

    return ticket;
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
@Override
public boolean deleteTicket(final String ticketIdToDel) {
    if (this.client == null) {
        logger.debug("No memcached client is configured.");
        return false;
    }

    final String ticketId = encodeTicketId(ticketIdToDel);
    if (ticketId == null) {
        return false;
    }

    final Ticket ticket = getTicket(ticketId);
    if (ticket == null) {
        return false;
    }

    if (ticket instanceof TicketGrantingTicket) {
        logger.debug("Removing ticket children [{}] from the registry.", ticket);
        deleteChildren((TicketGrantingTicket) ticket);
    }

    logger.debug("Deleting ticket {}", ticketId);
    try {
        return this.client.delete(ticketId).get();
    } catch (final Exception e) {
        logger.error("Ticket not found or is already removed. Failed deleting {}", ticketId, e);
    }
    return false;
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
public int sessionCount() {
    int count = 0;
    for (Ticket t : this.cache.values()) {
        if (t instanceof TicketGrantingTicket) {
            count++;
        }
    }
    return count;
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
@Test
public void deleteTicketRemovesFromCacheReturnsTrue() {
    final Ticket ticket = getTicket();
    infinispanTicketRegistry.addTicket(ticket);
    assertTrue(infinispanTicketRegistry.deleteTicket(ticket.getId()) == 1);
    assertNull(infinispanTicketRegistry.getTicket(ticket.getId()));
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
@Test
public void verifyGetTicketsFromRegistryEqualToTicketsAdded() {
    final Collection<Ticket> tickets = new ArrayList<>();

    for (int i = 0; i < TICKETS_IN_REGISTRY; i++) {
        final TicketGrantingTicket ticketGrantingTicket = new TicketGrantingTicketImpl("TEST" + i,
                TestUtils.getAuthentication(), new NeverExpiresExpirationPolicy());
        final ServiceTicket st = ticketGrantingTicket.grantServiceTicket("tests" + i,
                org.jasig.cas.services.TestUtils.getService(),
                new NeverExpiresExpirationPolicy(), false, true);
        tickets.add(ticketGrantingTicket);
        tickets.add(st);
        this.ticketRegistry.addTicket(ticketGrantingTicket);
        this.ticketRegistry.addTicket(st);
    }

    try {
        final Collection<Ticket> ticketRegistryTickets = this.ticketRegistry.getTickets();
        assertEquals("The size of the registry is not the same as the collection.", ticketRegistryTickets.size(),
                tickets.size());

        for (final Ticket ticket : tickets) {
            if (!ticketRegistryTickets.contains(ticket)) {
                fail("Ticket was added to registry but was not found in retrieval of collection of all tickets.");
            }
        }
    } catch (final Exception e) {
        logger.error(e.getMessage(), e);
        fail("Caught an exception. But no exception should have been thrown.");
    }
}
 

import org.jasig.cas.ticket.Ticket; //导入依赖的package包/类
@Override
public Collection<Ticket> getTickets() {
    try {
        final Node<String, Ticket> node = this.cache.getNode(FQN_TICKET);

        if (node == null) {
            return Collections.emptyList();
        }

        final Set<String> keys = node.getKeys();
        final List<Ticket> list = new ArrayList<Ticket>();

        for (final String key : keys) {

            /**  Returns null if the node contains no mapping for this key. **/
            final Ticket ticket = node.get(key);

            if (ticket != null) {
                list.add(node.get(key));
            }
        }

        return list;
    } catch (final CacheException e) {
        return Collections.emptyList();
    }
}