* Copyright © 2012 Alcatel-Lucent.

*

* See the NOTICE file distributed with this work for additional

* information regarding copyright ownership.

* Licensed 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.

*/

  private static final CategoryLogger logger = CategoryLoggerFactory.getLogger(DataManager.class, Category.DMGR);

  // Is tables already initialized or not.

  private boolean isHazelCastTablesInitialized = false;

  // On SystemManager only

  private ICacheTable<String, ApiDetail> cachingTableApiDetails;

  private ICacheTable<String, AuthDetail> cachingTableAuthDetails;

  private ICacheTable<String, String> cachingTableAuthIdToAuthToken;

  private ICacheTable<String, KeyDetail> cachingTableKeyDetails;

  private ICacheTable<String, CertificateDetail> cachingTableCertificateDetails;

  private ICacheTable<String, CertificateDetail> cachingTableCADetails;

  // On SystemManager only, recreated at startup

  // => At startup, check all policies and all buckets, recreate Set<K>

  private Set<Integer> usedBucketIds = new HashSet<Integer>();

  private Set<String> usedEndpoints = new HashSet<String>();

  // On Gateway and SystemManager

  private ICacheTable<String, Api> cachingTableApi;

  private ICacheTable<String, Auth> cachingTableAuth;

  private ICacheTable<String, String> cachingTableAuthIpAddress;

  private ICacheTable<String, Policy> cachingTablePolicy;

  private ICacheTable<Integer, ContextWrapper> cachingTableContext;

  private ICacheTable<String, String> cachingTableSettings;

  private ICacheTable<String, Key> cachingTableKey;

  private ICacheTable<String, Certificate> cachingTableCertificate;

  private ICacheTable<String, LogLevel> cachingTableLogLevel;

  private ICacheTable<String, Certificate> cachingTableCA;

  private ICacheTable<String, SSLCRL> cachingTableCRL;

  private ICacheTable<String, ApiJar> cachingTableApiJars; // table with acknowledgement service

  private ICacheManager cacheManager;

  private ITopologyClient topologyClient;

  protected boolean manager;

  private ReentrantLock dataManagerReadyLock = new ReentrantLock();

  // DataManagerListeners

  private Set<IDataManagerListener> listeners = new HashSet<IDataManagerListener>();

  private Set<IDataManagerUsedBucketIdsListener> usedBucketIdslisteners = new HashSet<IDataManagerUsedBucketIdsListener>();

  protected HandlerPool<String, MapHandler<String, ApiJar>> mapHandlerPool = new HandlerPool<String, MapHandler<String, ApiJar>>(E3Constant.HAZELCAST_HANDLER_POOL_MAX_SIZE);

  public DataManager() {

    /* Create fake table objects. */

    cachingTableApiDetails = new SanityCheckCacheTable<String, ApiDetail>("cachingTableApiDetails");

    cachingTableAuthDetails  = new SanityCheckCacheTable<String, AuthDetail>("cachingTableAuthDetails");

    cachingTableAuthIdToAuthToken = new SanityCheckCacheTable<String, String>("cachingTableAuthIdToAuthToken");

    cachingTableKeyDetails = new SanityCheckCacheTable<String, KeyDetail>("cachingTableKeyDetails");

    cachingTableCertificateDetails = new SanityCheckCacheTable<String, CertificateDetail>("cachingTableCertificateDetails");

    cachingTableCADetails = new SanityCheckCacheTable<String, CertificateDetail>("cachingTableCADetails");

    cachingTableApi = new SanityCheckCacheTable<String, Api>("cachingTableApi");

    cachingTableAuth = new SanityCheckCacheTable<String, Auth>("cachingTableAuth");

    cachingTableAuthIpAddress = new SanityCheckCacheTable<String, String>("cachingTableAuthIpAddress");

    cachingTablePolicy = new SanityCheckCacheTable<String, Policy>("cachingTablePolicy");

    cachingTableContext = new SanityCheckCacheTable<Integer, ContextWrapper>("cachingTableContext");

    cachingTableSettings = new SanityCheckCacheTable<String, String>("cachingTableSettings");

    cachingTableKey = new SanityCheckCacheTable<String, Key>("cachingTableKey");

    cachingTableCertificate = new SanityCheckCacheTable<String, Certificate>("cachingTableCertificate");

    cachingTableLogLevel = new SanityCheckCacheTable<String, LogLevel>("cachingTableLogLevel");

    cachingTableCA = new SanityCheckCacheTable<String, Certificate>("cachingTableCA");

    cachingTableCRL = new SanityCheckCacheTable<String, SSLCRL>("cachingTableCRL");

    cachingTableApiJars = new SanityCheckCacheTable<String, ApiJar>("cachingTableApiJars");

  }

  @Override

  public void addListener(IDataManagerListener listener) {

    dataManagerReadyLock.lock();

    try {

      this.listeners.add(listener);

      // assume that the DataManager is already ready at bean instantiation when we aren't a manager...

      if(isHazelCastTablesInitialized || !isManager()) {

        listener.dataManagerReady();

      }

    }

    finally {

      dataManagerReadyLock.unlock();

    }

  }

  @Override

  public void removeListener(IDataManagerListener listener) {

    this.listeners.remove(listener);

  } 

  @Override

  public void addListener(IDataManagerUsedBucketIdsListener listener) {

    this.usedBucketIdslisteners.add(listener);

  }

  @Override

  public void removeListener(IDataManagerUsedBucketIdsListener listener) {

    this.usedBucketIdslisteners.remove(listener);

  }

  private void populateBucketAndAPIIds() {

    for (ContextWrapper context : cachingTableContext.getAllValues()) {

      APIContext apiContext = context.getApiContext();

      if (apiContext != null) {

        usedBucketIds.add(apiContext.getBucketId());

      }

    }

    for (Policy policy : cachingTablePolicy.getAllValues()) {

      for (QuotaRLBucket bucket : policy.getAuthIds()) {

        usedBucketIds.add(bucket.getBucketId());

      }

    }

    for (Api api: cachingTableApi.getAllValues()) {

      usedBucketIds.add(api.getApiId());

    }

  }

  private void populateUsedEndpoints() {

    for(ApiDetail ad : cachingTableApiDetails.getAllValues()){

      usedEndpoints.add(ad.getEndpoint());

    }

  }

  public void setManager(boolean manager) {

    this.manager = manager;

  }

  private boolean isManager() {

    return manager;

  }

  public void init() {

    if (isManager()) {

      // register to know when the IP of DataStorage is changing

      this.topologyClient.addInstanceListener(this);

      createDataStoreTables();

    } else {

      // on the gateway, there is no data store and no replication

      setCachingTableApiDetails(cacheManager.createTable("cachingTableApiDetails", false, null));

      setCachingTableAuthDetails(cacheManager.createTable("cachingTableAuthDetails", false, null));

      setCachingTableAuthIdToAuthToken(cacheManager.createTable("cachingTableAuthIdToAuthToken", false, null));

      setCachingTableKeyDetails(cacheManager.createTable("cachingTableKeyDetails", false, null));

      setCachingTableCertificateDetails(cacheManager.createTable("cachingTableCertificateDetails", false, null));

      setCachingTableCADetails(cacheManager.createTable("cachingTableCADetails", false, null));

      setCachingTableApi(cacheManager.createTable("cachingTableApi", false, null));

      setCachingTableAuth(cacheManager.createTable("cachingTableAuth", false, null));

      setCachingTableAuthIpAddress(cacheManager.createTable("cachingTableAuthIpAddress", false, null));

      setCachingTablePolicy(cacheManager.createTable("cachingTablePolicy", false, null));

      setCachingTableKey(cacheManager.createTable("cachingTableKey", false, null));

      setCachingTableCertificate(cacheManager.createTable("cachingTableCertificate", false, null));

      setCachingTableCA(cacheManager.createTable("cachingTableCA", false, null));

      setCachingTableCRL(cacheManager.createTable("cachingTableCRL", false, null));

      setCachingTableContext(cacheManager.createTable("cachingTableContext", false, null));

      setCachingTableSettings(cacheManager.createTable("cachingTableSettings", false, null));

      setCachingTableApiJars(cacheManager.createTable("cachingTableApiJars", false, null));

      setCachingTableLogLevel(cacheManager.createTable("cachingTableLogLevel", false, null));

      isHazelCastTablesInitialized = true;

      // Inform listeners for DataManager Ready

      fireDataManagerReady();

    }

  }

  public void destroy() {

    if (this.topologyClient != null) {

      this.topologyClient.removeInstanceListener(this);

    }

  }

  private void fireDataManagerReady() {

    dataManagerReadyLock.lock();

    try {

      // do it on a copy of the listener in case of the listener list is modified during the loop

      IDataManagerListener[] currentListOfListeners = listeners.toArray(new IDataManagerListener[]{});

      for(IDataManagerListener listener : currentListOfListeners) {

        listener.dataManagerReady();

      }

    }

    finally {

      dataManagerReadyLock.unlock();

    }

  }

  private synchronized void createDataStoreTables() {

    // protect for multiple instantiation

    if (!isHazelCastTablesInitialized) {

      // create the tables if the IP of DataStorage is known

      List<Instance> dsInfoList = topologyClient.getAllInstancesOfType(E3Constant.DATA_STORAGE);

      if (dsInfoList != null && dsInfoList.size() > 0) {

        if(logger.isDebugEnabled()){

          logger.debug("DataManager initializing cache tables");

        }

        Instance dsInfo = dsInfoList.get(0);

        Map<String, String> properties = new HashMap<String, String>();

        properties.put("map-store-ip", dsInfo.getInternalIP());

        properties.put("map-store-port", dsInfo.getPort());

        properties.put("map-store-user", dsInfo.getUser());

        properties.put("map-store-password", dsInfo.getPassword());

        properties.put("map-store-name", "apiDetails");

        setCachingTableApiDetails(cacheManager.createTable("cachingTableApiDetails", false, properties));

        properties.put("map-store-name", "authDetails");

        setCachingTableAuthDetails(cacheManager.createTable("cachingTableAuthDetails", false, properties));

        properties.put("map-store-name", "authIdToAuthToken");

        setCachingTableAuthIdToAuthToken(cacheManager.createTable("cachingTableAuthIdToAuthToken", false, properties));

        properties.put("map-store-name", "keyDetails");

        setCachingTableKeyDetails(cacheManager.createTable("cachingTableKeyDetails", false, properties));

        properties.put("map-store-name", "certificateDetails");

        setCachingTableCertificateDetails(cacheManager.createTable("cachingTableCertificateDetails", false, properties));

        properties.put("map-store-name", "caDetails");

        setCachingTableCADetails(cacheManager.createTable("cachingTableCADetails", false, properties));

        properties.put("map-store-name", "api");

        setCachingTableApi(cacheManager.createTable("cachingTableApi", true, properties));

        properties.put("map-store-name", "auth");

        setCachingTableAuth(cacheManager.createTable("cachingTableAuth", true, properties));

        properties.put("map-store-name", "authIpAddress");

        setCachingTableAuthIpAddress(cacheManager.createTable("cachingTableAuthIpAddress", true, properties));

        properties.put("map-store-name", "policy");

        setCachingTablePolicy(cacheManager.createTable("cachingTablePolicy", true, properties));

        properties.put("map-store-name", "key");

        setCachingTableKey(cacheManager.createTable("cachingTableKey", true, properties));

        properties.put("map-store-name", "certificate");

        setCachingTableCertificate(cacheManager.createTable("cachingTableCertificate", true, properties));

        properties.put("map-store-name", "ca");

        setCachingTableCA(cacheManager.createTable("cachingTableCA", true, properties));

        properties.put("map-store-name", "crl");

        setCachingTableCRL(cacheManager.createTable("cachingTableCRL", true, properties));

        properties.put("map-store-name", "context");

        setCachingTableContext(cacheManager.createTable("cachingTableContext", true, properties));

        setCachingTableSettings(cacheManager.createTable("cachingTableSettings", true, null));

        properties.put("map-store-name", "jars");

        setCachingTableApiJars(cacheManager.createTable("cachingTableApiJars", true, properties));

        properties.put("map-store-name", "logLevel");

        setCachingTableLogLevel(cacheManager.createTable("cachingTableLogLevel", true, properties));

        populateBucketAndAPIIds();

        populateUsedEndpoints();

        isHazelCastTablesInitialized = true;

        // Inform listeners for DataManager Ready

        fireDataManagerReady();

        // no need to be notified on the topology again

        this.topologyClient.removeInstanceListener(this);

        // TODO: Clean

        //this.topologyClient = null;

      }

    }

  }

  @Override

  public void setCacheManager(ICacheManager cacheManager) {

    this.cacheManager = cacheManager;

  }

  @Override

  public void reloadGateway(String ip) {

    // Launch the provisioning of a gateway in a dedicated thread

    (new Thread (new RunnableProvisionGateway(ip))).start();

  }

  public void setTopologyClient(ITopologyClient topologyClient) {

    this.topologyClient = topologyClient;

  }

  @Override

  public Set<String> getAllApiIds() {   

    HashSet<String> ks = new HashSet<String>();

    ClassLoader previousClassLoader = Thread.currentThread().getContextClassLoader();

    Thread.currentThread().setContextClassLoader(DataManager.class.getClassLoader());

    for (Api api : cachingTableApi.getAllValues()) {

      if (!api.getInternal()) {

        ks.add(api.getId());

      }

    }

    Thread.currentThread().setContextClassLoader(previousClassLoader);

    return ks;

  }

  @Override

  public boolean isApiExist (String apiId) {

    return cachingTableApi.containsKey(apiId);

  }

  @Override

  public void addApi(Api api) {

    if (cachingTableApi.containsKey(api.getId()))

      throw new IllegalArgumentException("API already exists with that ID [" + api.getId() + "]");

    internalSaveApiDetails(api);

    boolean ok = false;

    while (!ok) {

      int idx = (int)(Math.random() * Integer.MAX_VALUE);

      Integer apiId = Integer.valueOf(idx);

      if (!usedBucketIds.contains(apiId)) {

        api.setApiId(apiId);

        usedBucketIds.add(apiId);

        ok = true;

      }

    }

    cachingTableApi.set(api.getId(), api);

    usedEndpoints.add(api.getApiDetail().getEndpoint());

  }

  @Override

  public boolean endpointExists(String endpoint){

    return usedEndpoints.contains(endpoint);

  }

  private void internalSaveApiDetails(Api api)

  {

    /* if no details, nothing to do. */

    if (api.getApiDetail() == null)

      return;

    api.setStatus(api.getApiDetail().getStatus());

    cachingTableApiDetails.set(api.getId(), api.getApiDetail());

    // Store all contexts aside, indexed by an int

    for (APIContext ctx : api.getApiDetail().getContexts()) {

      boolean ok = false;

      while (!ok) {

        int idx = (int)(Math.random() * Integer.MAX_VALUE);

        Integer contextId = Integer.valueOf(idx);

        if (!cachingTableContext.containsKey(contextId)) {

          ctx.setContextId(contextId);

          // API context should also be seen as a Bucket

          boolean ok2 = false;

          while (!ok2) {

            int idx2 = (int)(Math.random() * Integer.MAX_VALUE);

            Integer bucketId = Integer.valueOf(idx2);

            if (!usedBucketIds.contains(bucketId)) {

              ctx.setBucketId(bucketId);

              usedBucketIds.add(bucketId);

              ok2 = true;

            }

          }

          cachingTableContext.set(contextId, new ContextWrapper(ctx));

          // If this APIContext is the default one, adding it at index 0 ; this is the place where we're

          // looking for it in getMatchingPolicies

          ApiIds apiIds = new ApiIds(ctx.getId(), ctx.getContextId(), ctx.getBucketId(), ctx.getStatus()==StatusType.ACTIVE);

          if(ctx.isDefaultContext())

            api.getContextIds().add(0, apiIds);

          else

            api.getContextIds().add(apiIds);

          ok = true;

        }

      }

    }

  }

  @Override

  public void updateApi(Api api) throws InvalidIDException {

    Api oldApi = cachingTableApi.get(api.getId());

    if (oldApi == null)

      throw new InvalidIDException("An API with that ID [" + api.getId() + "] doesn't exist");

    // Remove all contexts and bucket ids

    for (ApiIds apiIds : oldApi.getContextIds()) {

      cachingTableContext.remove(Integer.valueOf(apiIds.getApiContextId()));

      usedBucketIds.remove(Integer.valueOf(apiIds.getApiBucketId()));

      for (IDataManagerUsedBucketIdsListener listner : this.usedBucketIdslisteners)

      {

        listner.usedBucketIdsRemoved(new Integer(apiIds.getApiBucketId()));

      }

    }

    // Remove endpoint from the used endpoints

    ApiDetail oldDetail = cachingTableApiDetails.get(api.getId());

    usedEndpoints.remove(oldDetail.getEndpoint());

    // add updated contexts

    internalSaveApiDetails(api);

    api.setPolicyIds(oldApi.getPolicyIds());

    cachingTableApi.set(api.getId(), api);

    usedEndpoints.add(api.getApiDetail().getEndpoint());

  }

  @Override

  public void removeApi(String id) throws InvalidIDException {

    Api api = cachingTableApi.remove(id);

    ApiDetail detail = cachingTableApiDetails.remove(id);

    if (api == null) {

      throw new InvalidIDException("An API with that ID [" + id + "] doesn't exist");

    }

    // Find the policies associated, and remove this API

    for (String policyId : api.getPolicyIds()) {

      Policy policy = getPolicyById(policyId);

      if (policy != null) {

        policy.getApiIds().remove(api.getId());

        cachingTablePolicy.set(policyId, policy);

      }

    }

    // Remove the contexts

    for (ApiIds apiIds : api.getContextIds()) {

      cachingTableContext.remove(Integer.valueOf(apiIds.getApiContextId()));

      usedBucketIds.remove(new Integer(apiIds.getApiBucketId()));

      for (IDataManagerUsedBucketIdsListener listner : this.usedBucketIdslisteners)

      {

        listner.usedBucketIdsRemoved(new Integer(apiIds.getApiBucketId()));

      }

    }

    // Remove endpoint from the used endpoints

    usedEndpoints.remove(detail.getEndpoint());

    usedBucketIds.remove(api.getApiId());

    for (IDataManagerUsedBucketIdsListener listner : this.usedBucketIdslisteners)

    {

      listner.usedBucketIdsRemoved(new Integer(api.getApiId()));

    }

  }

  @Override

  public Api getApiById(String id) {

    return getApiById(id, false);

  }

  @Override

  public Api getApiById(String id, boolean getFullDetails) throws InvalidIDException {

    Api api = cachingTableApi.get(id);

    if (api == null) {

      throw new InvalidIDException("An API with that ID [" + id + "] doesn't exist");

    }

    if (getFullDetails) {

      ApiDetail details = cachingTableApiDetails.get(id);

      if (details != null) {

        api.setApiDetail(details);

        // It's not because List<Context> is transient on ApiDetail

        // that it isn't stored in hazelcast memory locally.

        // For sure, it will not be replicated

        details.getContexts().clear();

        // We can't be sure here to reuse existing List<APIContext>

        // it may be not up to date.

        for (ApiIds ids : api.getContextIds()) {

          details.getContexts().add(cachingTableContext.get(ids.getApiContextId()).getApiContext());

        }

      }

    }

    else

      api.setApiDetail(null);

    return api;

  }

  private String byteToString(byte[] data) {

    String result = null;

    if (data != null) {

      result = new String(data).toString();

    } else {

      result = new String();

    }

    return result;

  }

 

  /**

   * Uses SHA1 algorithm to hash authId.

   * @param auth

   * @return The hexa conversion of SHA-1(auth)

   */

  private String hashAuthId(String auth){

    return DigestUtils.shaHex(auth);

  }

  private String createTokenFromAuth(Auth auth) {

    if (auth.getAuthDetail() == null)

      return null;

    if (auth.getAuthDetail().getType() == NBAuthType.AUTHKEY)

      return createTokenFromAuthKey(auth.getAuthDetail().getAuthKeyValue());

    if (auth.getAuthDetail().getType() == NBAuthType.OAUTH)

      return createTokenFromOAuth(auth.getAuthDetail().getClientId(), auth.getAuthDetail().getClientSecret());

    if (auth.getAuthDetail().getType() == NBAuthType.BASIC)

      return createTokenFromUserPass(auth.getAuthDetail().getUsername(), byteToString(auth.getAuthDetail().getPassword()));

    if (auth.getAuthDetail().getType() == NBAuthType.WSSE)

      return createWsseTokenFromUser(auth.getAuthDetail().getUsername());

    if (auth.getAuthDetail().getType() == NBAuthType.IP_WHITE_LIST)

      return auth.getId();

    throw new IllegalArgumentException("Unknown authentication type [" + auth.getAuthDetail().getType() + "]");

  }

  private String createTokenFromAuthKey(String authKey) {

    return authKey;

  }

  private String createTokenFromOAuth(String clientId, String clientSecret) {

    return clientId + ";"/* + clientSecret*/;

  }

  private String createTokenFromUserPass(String username, String password) {

    // Encrypt

    return username + ":" + hashAuthId(password);

  }

  private String createWsseTokenFromUser(String username) {

    return username + ":";

  }

  @Override

  public Set<String> getAllAuthIds() {

    return cachingTableAuthIdToAuthToken.getAllKeys();

  }

  @Override

  public void addAuth(Auth auth) {

    if (cachingTableAuthIdToAuthToken.containsKey(auth.getId()))

      throw new IllegalArgumentException("Auth already exists with that ID [" + auth.getId() + "]");

    String authToken = createTokenFromAuth(auth);

    Auth auth2 = cachingTableAuth.get(authToken);

    if (auth2 != null)

      throw new IllegalArgumentException("An authorization with the same credentials already exist");

    // For each IP address, check if the IP already exist

    if (auth.getAuthDetail() != null)  {

      if (auth.getAuthDetail().getType() == NBAuthType.IP_WHITE_LIST) {

        for (String ip : auth.getAuthDetail().getWhiteListedIps()) {

          if (cachingTableAuthIpAddress.containsKey(ip))

            throw new IllegalArgumentException("An authorization with the same IP address already exist");

        }

      }

    }

    cachingTableAuthIdToAuthToken.set(auth.getId(), authToken);

    cachingTableAuth.set(authToken, auth);

    if (auth.getAuthDetail() != null) {

      cachingTableAuthDetails.set(authToken, auth.getAuthDetail());

      if (auth.getAuthDetail().getType() == NBAuthType.IP_WHITE_LIST) {

        for (String ip : auth.getAuthDetail().getWhiteListedIps()) {

          cachingTableAuthIpAddress.set(ip, authToken);

        }

      }

    }

  }

  @Override

  public void updateAuth(Auth auth) throws InvalidIDException {

    // Get old Auth

    String oldAuthToken = cachingTableAuthIdToAuthToken.get(auth.getId());

    if (oldAuthToken == null)

      throw new InvalidIDException("An authorization with that ID [" + auth.getId() + "] doesn't exist");

    // For each IP address, check if the IP already exist

    if (auth.getAuthDetail() != null)  {

      if (auth.getAuthDetail().getType() == NBAuthType.IP_WHITE_LIST) {

        for (String ip : auth.getAuthDetail().getWhiteListedIps()) {

          String authToken = cachingTableAuthIpAddress.get(ip);

          if ((authToken != null) && (authToken.equals(oldAuthToken) == false))

            throw new IllegalArgumentException("An authorization with the same IP address already exist");

        }

      }

    }

    AuthDetail authDetail = cachingTableAuthDetails.get(oldAuthToken);

    if (authDetail != null) {