Java tutorial
/* * Copyright 2010-2013 Ning, Inc. * Copyright 2014-2017 Groupon, Inc * Copyright 2014-2017 The Billing Project, LLC * * The Billing Project licenses this file to you under the Apache License, version 2.0 * (the "License"); you may not use this file except in compliance with the * License. You may obtain a copy of the License at: * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the * License for the specific language governing permissions and limitations * under the License. */ package org.killbill.billing.tenant.api.user; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.UUID; import org.killbill.billing.ErrorCode; import org.killbill.billing.ObjectType; import org.killbill.billing.callcontext.InternalCallContext; import org.killbill.billing.callcontext.InternalTenantContext; import org.killbill.billing.tenant.api.DefaultTenant; import org.killbill.billing.tenant.api.Tenant; import org.killbill.billing.tenant.api.TenantApiException; import org.killbill.billing.tenant.api.TenantData; import org.killbill.billing.tenant.api.TenantKV.TenantKey; import org.killbill.billing.tenant.api.TenantUserApi; import org.killbill.billing.tenant.dao.TenantDao; import org.killbill.billing.tenant.dao.TenantKVModelDao; import org.killbill.billing.tenant.dao.TenantModelDao; import org.killbill.billing.util.cache.Cachable.CacheType; import org.killbill.billing.util.cache.CacheController; import org.killbill.billing.util.cache.CacheControllerDispatcher; import org.killbill.billing.util.cache.CacheLoaderArgument; import org.killbill.billing.util.callcontext.CallContext; import org.killbill.billing.util.callcontext.InternalCallContextFactory; import org.killbill.billing.util.callcontext.TenantContext; import com.google.common.base.Predicate; import com.google.common.collect.ImmutableList; import com.google.common.collect.Iterables; import com.google.inject.Inject; public class DefaultTenantUserApi implements TenantUserApi { // // Most System TenantKey are cached in the 'tenant-kv' cache owned by the Tenant module; however // - xml value keys such as OVERDUE_CONFIG, CATALOG are cached at a higher level to avoid reconstruct the objects from xml // - any keys that require multiple values would not be cached (today we only have CATALOG and this is not cached in 'tenant-kv' cache), // so that means all other TenantKey could be cached at this level // // CACHED_TENANT_KEY is not exposed in the API and is hardcoded here since this is really a implementation choice. // public static final Iterable<TenantKey> CACHED_TENANT_KEY = ImmutableList.<TenantKey>builder() .add(TenantKey.CATALOG_TRANSLATION_).add(TenantKey.INVOICE_MP_TEMPLATE).add(TenantKey.INVOICE_TEMPLATE) .add(TenantKey.INVOICE_TRANSLATION_).add(TenantKey.PLUGIN_CONFIG_) .add(TenantKey.PLUGIN_PAYMENT_STATE_MACHINE_).add(TenantKey.PUSH_NOTIFICATION_CB).build(); private final TenantDao tenantDao; private final InternalCallContextFactory internalCallContextFactory; private final CacheController<String, String> tenantKVCache; private final CacheController<String, Tenant> tenantCache; @Inject public DefaultTenantUserApi(final TenantDao tenantDao, final InternalCallContextFactory internalCallContextFactory, final CacheControllerDispatcher cacheControllerDispatcher) { this.tenantDao = tenantDao; this.internalCallContextFactory = internalCallContextFactory; this.tenantKVCache = cacheControllerDispatcher.getCacheController(CacheType.TENANT_KV); this.tenantCache = cacheControllerDispatcher.getCacheController(CacheType.TENANT); } @Override public Tenant createTenant(final TenantData data, final CallContext context) throws TenantApiException { final Tenant tenant = new DefaultTenant(data); if (null != tenant.getExternalKey() && tenant.getExternalKey().length() > 255) { throw new TenantApiException(ErrorCode.EXTERNAL_KEY_LIMIT_EXCEEDED); } try { tenantDao.create(new TenantModelDao(tenant), internalCallContextFactory.createInternalCallContextWithoutAccountRecordId(context)); } catch (final TenantApiException e) { throw new TenantApiException(e, ErrorCode.TENANT_CREATION_FAILED); } return tenant; } @Override public Tenant getTenantByApiKey(final String key) throws TenantApiException { final Tenant tenant = tenantCache.get(key, new CacheLoaderArgument(ObjectType.TENANT)); if (tenant == null) { throw new TenantApiException(ErrorCode.TENANT_DOES_NOT_EXIST_FOR_API_KEY, key); } return tenant; } @Override public Tenant getTenantById(final UUID id) throws TenantApiException { // TODO - API cleanup? final TenantModelDao tenant = tenantDao.getById(id, new InternalTenantContext(null)); if (tenant == null) { throw new TenantApiException(ErrorCode.TENANT_DOES_NOT_EXIST_FOR_ID, id); } return new DefaultTenant(tenant); } @Override public List<String> getTenantValuesForKey(final String key, final TenantContext context) throws TenantApiException { final InternalTenantContext internalContext = internalCallContextFactory .createInternalTenantContextWithoutAccountRecordId(context); if (!isCachedInTenantKVCache(key)) { return tenantDao.getTenantValueForKey(key, internalContext); } else { return getCachedTenantValuesForKey(key, internalContext); } } @Override public void addTenantKeyValue(final String key, final String value, final CallContext context) throws TenantApiException { // Invalidate tenantKVCache after we store (to avoid race conditions). Multi-node invalidation will follow the TenantBroadcast pattern final InternalCallContext internalContext = internalCallContextFactory .createInternalCallContextWithoutAccountRecordId(context); final String tenantKey = getCacheKeyName(key, internalContext); tenantDao.addTenantKeyValue(key, value, isSingleValueKey(key), internalContext); tenantKVCache.remove(tenantKey); } @Override public void updateTenantKeyValue(final String key, final String value, final CallContext context) throws TenantApiException { // Invalidate tenantKVCache after we store (to avoid race conditions). Multi-node invalidation will follow the TenantBroadcast pattern final InternalCallContext internalContext = internalCallContextFactory .createInternalCallContextWithoutAccountRecordId(context); final String tenantKey = getCacheKeyName(key, internalContext); tenantDao.updateTenantLastKeyValue(key, value, internalContext); tenantKVCache.remove(tenantKey); } @Override public void deleteTenantKey(final String key, final CallContext context) throws TenantApiException { // Invalidate tenantKVCache after we delete (to avoid race conditions). Multi-node invalidation will follow the TenantBroadcast pattern final InternalCallContext internalContext = internalCallContextFactory .createInternalCallContextWithoutAccountRecordId(context); final String tenantKey = getCacheKeyName(key, internalContext); tenantDao.deleteTenantKey(key, internalContext); tenantKVCache.remove(tenantKey); } @Override public Map<String, List<String>> searchTenantKeyValues(String searchKey, TenantContext context) throws TenantApiException { final InternalTenantContext internalContext = internalCallContextFactory .createInternalTenantContextWithoutAccountRecordId(context); final List<TenantKVModelDao> daoResult = tenantDao.searchTenantKeyValues(searchKey, internalContext); final Map<String, List<String>> result = new HashMap<String, List<String>>(); for (final TenantKVModelDao cur : daoResult) { if (!result.containsKey(cur.getTenantKey())) { result.put(cur.getTenantKey(), new ArrayList<String>()); } result.get(cur.getTenantKey()).add(cur.getTenantValue()); } return result; } private List<String> getCachedTenantValuesForKey(final String key, final InternalTenantContext internalContext) { final String tenantKey = getCacheKeyName(key, internalContext); final Object cachedTenantValues = tenantKVCache.get(tenantKey, new CacheLoaderArgument(ObjectType.TENANT_KVS)); if (cachedTenantValues == null) { return ImmutableList.<String>of(); } else { // Current, we only cache single-value keys return ImmutableList.<String>of((String) cachedTenantValues); } } private String getCacheKeyName(final String key, final InternalTenantContext internalContext) { final StringBuilder tenantKey = new StringBuilder(key); tenantKey.append(CacheControllerDispatcher.CACHE_KEY_SEPARATOR); tenantKey.append(internalContext.getTenantRecordId()); return tenantKey.toString(); } private boolean isSingleValueKey(final String key) { return Iterables.tryFind(ImmutableList.copyOf(TenantKey.values()), new Predicate<TenantKey>() { @Override public boolean apply(final TenantKey input) { return input.isSingleValue() && key.startsWith(input.toString()); } }).orNull() != null; } private boolean isCachedInTenantKVCache(final String key) { return Iterables.tryFind(CACHED_TENANT_KEY, new Predicate<TenantKey>() { @Override public boolean apply(final TenantKey input) { return key.startsWith(input.toString()); } }).orNull() != null; } }