Java Code Examples for javax.ejb.LockType#READ

@Lock(LockType.READ)
public void doTimerWork() throws InterruptedException {

    System.out.println("Timer method called but not started yet !");

    if (!busy.compareAndSet(false, true)) {
        return;
    }

    try {
        System.out.println("Timer work started");
        Thread.sleep(12000);
        System.out.println("Timer work done");
    } finally {
        busy.set(false);
    }
}
 

@Override
@Lock(LockType.READ)
public void notifyListeners(ChangeSet changeSet) {
    if (changeSet == null)
        throw new IllegalArgumentException("changeSet must not be null");
    this.performNotification(changeSet);
}
 

@Lock(LockType.READ)
public List<Order> getOrders() {
    final ArrayList<Order> orders = new ArrayList<>(this.orders.values());
    orders.sort(Comparator.comparing(Order::getId));

    return orders;
}
 

@Override
@Lock(LockType.READ)
public String serialize(List<? extends Serializable> events) {
    if (events == null)
        throw new IllegalArgumentException("events must not be null");
    EventList evlist = new EventList(events);
    return gson.toJson(evlist);
}
 

@Override
@Lock(LockType.READ)
public List<? extends Serializable> deserialize(String body) {
    if (body == null)
        throw new IllegalArgumentException("body must not be null");
    log.log(Level.FINER, "deserializing body: " + body);
    return this.gson.fromJson(body, EventList.class).events();
}
 

@Lock(LockType.READ)
public void readerMethod(int threadId) {
	System.out.println("Enter READER " + threadId + ". R:" + readerCount.incrementAndGet() + "/w:"
			+ writerCount.get());
	try {
		Thread.sleep(300);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
	System.out.println("Exit READER " + threadId + ". R:" + readerCount.decrementAndGet() + "/w:"
			+ writerCount.get());
}
 

@Lock(LockType.READ)
public Order getOrder(long id) {
    return orders.get(id);
}
 

@Lock(LockType.READ) //override default: allow concurrent access
@Override
public void incrementCounter() {
    x = x + 1;
}
 

@Lock(LockType.READ)
public Set<Session> getAll() {
    return Collections.unmodifiableSet(sessions);
}
 

@Lock(LockType.READ)
public Set<BookSelection> getSelections() {
    return Collections.unmodifiableSet(selections);
}
 

@Lock(LockType.READ)
public Order getOrder(long id) {
    return orders.get(id);
}
 

@Lock(LockType.READ)
public BookSelection getSelection(long selectionId) {
    return selections.stream()
            .filter(s -> s.getId() == selectionId).findAny()
            .orElse(null);
}
 

@Lock(LockType.READ)
public Set<BookSelection> getSelections() {
    return Collections.unmodifiableSet(selections);
}
 

@Override
@Lock(LockType.READ)
public JsonObject getTrustAnchors(String aaguid, List<String> allowedStatusList) {
    JsonObjectBuilder ret = Json.createObjectBuilder();
    JsonArrayBuilder errors = Json.createArrayBuilder();
    JsonObjectBuilder error = Json.createObjectBuilder();
    MetadataTOCPayloadEntry entry = null;
    MetadataStatement st = null;

    for (MDSService service : mdsList) {
        entry = service.getTOCEntry(aaguid);
        if (entry!=null) {
            for (StatusReport status : entry.getStatusReports()) {
                if (status.getStatus()==AuthenticatorStatus.ATTESTATION_KEY_COMPROMISE ||
                        status.getStatus()==AuthenticatorStatus.REVOKED ||
                        status.getStatus()==AuthenticatorStatus.USER_KEY_PHYSICAL_COMPROMISE ||
                        status.getStatus()==AuthenticatorStatus.USER_KEY_REMOTE_COMPROMISE ||
                        status.getStatus()==AuthenticatorStatus.USER_VERIFICATION_BYPASS
                        ) {
                    error.add("message", "Authenticator status = "+status.getStatus().name());
                    errors.add(error);
                }
                else if(!allowedStatusList.contains(status.getStatus().name())){
                    error.add("message", "Authenticator status = " + status.getStatus().name() + "not allowed by policy");
                    errors.add(error);
                }
            }
        }

        st = service.getMetadataStatement(aaguid);
        if (st != null) {
            List<String> attestationRootCertificates = st.getAttestationRootCertificates();
            if (attestationRootCertificates != null) {
                JsonArrayBuilder certs = Json.createArrayBuilder();
                for (String c : attestationRootCertificates) {
                    certs.add(c);
                    System.out.println("Certificate found : " + c);
                }

                ret.add("attestationRootCertificates", certs);
            }

            List<EcdaaTrustAnchor> ecdaaTrustAnchors = st.getEcdaaTrustAnchors();
            if (ecdaaTrustAnchors != null) {
                JsonArrayBuilder trustAnchors = Json.createArrayBuilder();
                for (EcdaaTrustAnchor t : ecdaaTrustAnchors) {
                    try {
                        trustAnchors.add(objectMapper.writeValueAsString(t));
                    } catch (JsonProcessingException ex) {
                        Logger.getLogger(MDS.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
                ret.add("ecdaaTrustAnchors", trustAnchors);
            }
            break;
        }
    }
    if (entry==null && st==null) {
        error.add("message", "Could not find metadata for aaguid "+aaguid);
        errors.add(error);
    }
    ret.add("errors", errors);
    return ret.build();
}
 

@Override
@Lock(LockType.READ)
public EntityManager entityManagerForWriting(String bucketId) {
    return entityManager;
}
 

@Lock(LockType.READ)
public BookSelection getSelection(final long selectionId) {
    return selections.stream().filter(s -> s.getId() == selectionId).findFirst().orElse(null);
}
 

@Lock(LockType.READ)
public Car retrieve(String id) {
    return cars.get(id);
}
 

@Lock(LockType.READ) //override default: allow concurrent access
@Override
public void incrementCounter() {
    x = x + 1;
}
 

@Lock(LockType.READ)
public int getUserCount(){
    return userCount;
}
 

@Override
@Lock(LockType.READ)
public EntityManager entityManagerForReading(String bucketId) {
    return entityManager;
}