org.killbill.commons.locker.GlobalLock.release java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Gson g =new Gson()
GsonBuilder gsonBuilder;gsonBuilder.create()
new GsonBuilder().create()
Smart code suggestions by Tabnine
}

public void clear(final DateTime effectiveDate, final InternalCallContext context) throws OverdueException, OverdueApiException {
  GlobalLock lock = null;
  try {
    lock = locker.lockWithNumberOfTries(LockerType.ACCNT_INV_PAY.toString(), overdueable.getId().toString(), MAX_LOCK_RETRIES);
    clearWithLock(effectiveDate, context);
  } catch (final LockFailedException e) {
    log.warn("Failed to clear overdue for accountId='{}'", overdueable.getId(), e);
  } finally {
    if (lock != null) {
      lock.release();
    }
  }
}

public OverdueState refresh(final DateTime effectiveDate, final InternalCallContext context) throws OverdueException, OverdueApiException {
  if (overdueStateSet.size() < 1) { // No configuration available
    return overdueStateSet.getClearState();
  }
  GlobalLock lock = null;
  try {
    lock = locker.lockWithNumberOfTries(LockerType.ACCNT_INV_PAY.toString(), overdueable.getId().toString(), MAX_LOCK_RETRIES);
    return refreshWithLock(effectiveDate, context);
  } catch (final LockFailedException e) {
    log.warn("Failed to process overdue for accountId='{}'", overdueable.getId(), e);
  } finally {
    if (lock != null) {
      lock.release();
    }
  }
  return null;
}

  @Test(groups = "slow")
  public void testSimpleLocking() throws IOException, LockFailedException {
    final String lockName = UUID.randomUUID().toString();

    final GlobalLock lock = locker.lockWithNumberOfTries(LockerType.ACCNT_INV_PAY.toString(), lockName, 3);

    dbi.inTransaction(new TransactionCallback<Void>() {
      @Override
      public Void inTransaction(final Handle conn, final TransactionStatus status)
          throws Exception {
        conn.execute("insert into dummy2 (dummy_id) values ('" + UUID.randomUUID().toString() + "')");
        return null;
      }
    });
    Assert.assertEquals(locker.isFree(LockerType.ACCNT_INV_PAY.toString(), lockName), false);

    boolean gotException = false;
    try {
      locker.lockWithNumberOfTries(LockerType.ACCNT_INV_PAY.toString(), lockName, 1);
    } catch (LockFailedException e) {
      gotException = true;
    }
    Assert.assertTrue(gotException);

    lock.release();

    Assert.assertEquals(locker.isFree(LockerType.ACCNT_INV_PAY.toString(), lockName), true);
  }
}

public Invoice processAccount(final boolean isApiCall,
               final UUID accountId,
               @Nullable final LocalDate targetDate,
               @Nullable final DryRunArguments dryRunArguments,
               final boolean isRescheduled,
               final InternalCallContext context) throws InvoiceApiException {
  boolean parkedAccount = false;
  try {
    parkedAccount = parkedAccountsManager.isParked(context);
    if (parkedAccount && !isApiCall) {
      log.warn("Ignoring invoice generation process for accountId='{}', targetDate='{}', account is parked", accountId.toString(), targetDate);
      return null;
    }
  } catch (final TagApiException e) {
    log.warn("Unable to determine parking state for accountId='{}'", accountId);
  }
  GlobalLock lock = null;
  try {
    lock = locker.lockWithNumberOfTries(LockerType.ACCNT_INV_PAY.toString(), accountId.toString(), invoiceConfig.getMaxGlobalLockRetries());
    return processAccountWithLock(parkedAccount, accountId, targetDate, dryRunArguments, isRescheduled, context);
  } catch (final LockFailedException e) {
    log.warn("Failed to process invoice for accountId='{}', targetDate='{}'", accountId.toString(), targetDate, e);
  } finally {
    if (lock != null) {
      lock.release();
    }
  }
  return null;
}

public void clear(final DateTime effectiveDate, final InternalCallContext context) throws OverdueException, OverdueApiException {
  GlobalLock lock = null;
  try {
    lock = locker.lockWithNumberOfTries(LockerType.ACCNT_INV_PAY.toString(), overdueable.getId().toString(), MAX_LOCK_RETRIES);
    clearWithLock(effectiveDate, context);
  } catch (final LockFailedException e) {
    log.warn("Failed to clear overdue for accountId='{}'", overdueable.getId(), e);
  } finally {
    if (lock != null) {
      lock.release();
    }
  }
}

public void processParentInvoiceForAdjustments(final Account childAccount, final UUID childInvoiceId, final InternalCallContext context) throws InvoiceApiException {
  GlobalLock lock = null;
  try {
    lock = locker.lockWithNumberOfTries(LockerType.ACCNT_INV_PAY.toString(), childAccount.getParentAccountId().toString(), invoiceConfig.getMaxGlobalLockRetries());
    processParentInvoiceForAdjustmentsWithLock(childAccount, childInvoiceId, context);
  } catch (final LockFailedException e) {
    log.warn("Failed to process parent invoice for parentAccountId='{}'", childAccount.getParentAccountId().toString(), e);
  } finally {
    if (lock != null) {
      lock.release();
    }
  }
}

public void processParentInvoiceForInvoiceGeneration(final Account childAccount, final UUID childInvoiceId, final InternalCallContext context) throws InvoiceApiException {
  GlobalLock lock = null;
  try {
    lock = locker.lockWithNumberOfTries(LockerType.ACCNT_INV_PAY.toString(), childAccount.getParentAccountId().toString(), invoiceConfig.getMaxGlobalLockRetries());
    processParentInvoiceForInvoiceGenerationWithLock(childAccount, childInvoiceId, context);
  } catch (final LockFailedException e) {
    log.warn("Failed to process parent invoice for parentAccountId='{}'", childAccount.getParentAccountId().toString(), e);
  } finally {
    if (lock != null) {
      lock.release();
    }
  }
}

public OverdueState refresh(final DateTime effectiveDate, final InternalCallContext context) throws OverdueException, OverdueApiException {
  if (overdueStateSet.size() < 1) { // No configuration available
    return overdueStateSet.getClearState();
  }
  GlobalLock lock = null;
  try {
    lock = locker.lockWithNumberOfTries(LockerType.ACCNT_INV_PAY.toString(), overdueable.getId().toString(), MAX_LOCK_RETRIES);
    return refreshWithLock(effectiveDate, context);
  } catch (final LockFailedException e) {
    log.warn("Failed to process overdue for accountId='{}'", overdueable.getId(), e);
  } finally {
    if (lock != null) {
      lock.release();
    }
  }
  return null;
}

public void processSubscriptionStartRequestedDate(final RequestedSubscriptionInternalEvent transition, final InternalCallContext context) {
  final long dryRunNotificationTime = invoiceConfig.getDryRunNotificationSchedule(context).getMillis();
  final boolean isInvoiceNotificationEnabled = dryRunNotificationTime > 0;
  if (!isInvoiceNotificationEnabled) {
    return;
  }
  final UUID accountId;
  try {
    accountId = subscriptionApi.getAccountIdFromSubscriptionId(transition.getSubscriptionId(), context);
  } catch (final SubscriptionBaseApiException e) {
    log.warn("Failed handling SubscriptionBase change.",
         new InvoiceApiException(ErrorCode.INVOICE_NO_ACCOUNT_ID_FOR_SUBSCRIPTION_ID, transition.getSubscriptionId().toString()));
    return;
  }
  GlobalLock lock = null;
  try {
    lock = locker.lockWithNumberOfTries(LockerType.ACCNT_INV_PAY.toString(), accountId.toString(), invoiceConfig.getMaxGlobalLockRetries());
    processSubscriptionStartRequestedDateWithLock(accountId, transition, context);
  } catch (final LockFailedException e) {
    log.warn("Failed to process RequestedSubscriptionInternalEvent for accountId='{}'", accountId.toString(), e);
  } finally {
    if (lock != null) {
      lock.release();
    }
  }
}

} finally {
  if (lock != null) {
    lock.release();

  @Test(groups = "slow")
  public void testSimpleLocking() throws IOException, LockFailedException {
    final String lockName = UUID.randomUUID().toString();

    final GlobalLock lock = locker.lockWithNumberOfTries(LockerType.ACCNT_INV_PAY.toString(), lockName, 3);

    dbi.inTransaction(new TransactionCallback<Void>() {
      @Override
      public Void inTransaction(final Handle conn, final TransactionStatus status)
          throws Exception {
        conn.execute("insert into dummy2 (dummy_id) values ('" + UUID.randomUUID().toString() + "')");
        return null;
      }
    });
    Assert.assertEquals(locker.isFree(LockerType.ACCNT_INV_PAY.toString(), lockName), false);

    boolean gotException = false;
    try {
      locker.lockWithNumberOfTries(LockerType.ACCNT_INV_PAY.toString(), lockName, 1);
    } catch (LockFailedException e) {
      gotException = true;
    }
    Assert.assertTrue(gotException);

    lock.release();

    Assert.assertEquals(locker.isFree(LockerType.ACCNT_INV_PAY.toString(), lockName), true);
  }
}

} finally {
  if (lock != null) {
    lock.release();

} finally {
  if (lock != null) {
    lock.release();

Popular methods of GlobalLock

Popular in Java

Start an intent from android
setScale (BigDecimal)
getOriginalFilename (MultipartFile)
Return the original filename in the client's filesystem.This may contain path information depending
onCreateOptionsMenu (Activity)
HttpServer (com.sun.net.httpserver)
This class implements a simple HTTP server. A HttpServer is bound to an IP address and port number a
GridBagLayout (java.awt)
The GridBagLayout class is a flexible layout manager that aligns components vertically and horizonta
URLEncoder (java.net)
This class is used to encode a string using the format required by application/x-www-form-urlencoded
KeyStore (java.security)
KeyStore is responsible for maintaining cryptographic keys and their owners. The type of the syste
AtomicInteger (java.util.concurrent.atomic)
An int value that may be updated atomically. See the java.util.concurrent.atomic package specificati
Table (org.hibernate.mapping)
A relational table
Sublime Text for Python

How to use releasemethodin org.killbill.commons.locker.GlobalLock

Best Java code snippets using org.killbill.commons.locker.GlobalLock.release (Showing top 13 results out of 315)

How to use
release
method
in
org.killbill.commons.locker.GlobalLock