• Home
• com.dell.cpsd
• hdp-capability-registry-client
• 1.0.0
• source code
• CapabilityBinder.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.dell.cpsd.hdp.capability.registry.client.binder.CapabilityBinder Maven / Gradle / Ivy

/**
 * Copyright © 2017 Dell Inc. or its subsidiaries.  All Rights Reserved.
 */

package com.dell.cpsd.hdp.capability.registry.client.binder;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import com.dell.cpsd.common.logging.ILogger;
import com.dell.cpsd.hdp.capability.registry.api.CapabilityProvider;
import com.dell.cpsd.hdp.capability.registry.client.CapabilityRegistryException;
import com.dell.cpsd.hdp.capability.registry.client.ICapabilityProviderRegistrationListener;
import com.dell.cpsd.hdp.capability.registry.client.ICapabilityRegistryLookupManager;
import com.dell.cpsd.hdp.capability.registry.client.log.HDCRLoggingManager;
import com.dell.cpsd.hdp.capability.registry.client.log.HDCRMessageCode;
import com.dell.cpsd.service.common.client.exception.ServiceTimeoutException;

/**
 * 

 * Copyright © 2017 Dell Inc. or its subsidiaries.  All Rights Reserved.
 * Dell EMC Confidential/Proprietary Information
 * 
 *
 * @since 1.0
 */
public class CapabilityBinder
{
    /**
     * The logger for this class.
     */
    private static final ILogger                            LOGGER             = HDCRLoggingManager.getLogger(CapabilityBinder.class);

    private final Map existingBindings   = Collections.synchronizedMap(new HashMap<>());
    private final CapabilityBindingService                  capabilityBindingService;
    private final List                   capabilityMatchers = new ArrayList<>();

    public CapabilityBinder(CapabilityBindingService capabilityBindingService, CapabilityMatcher... capabilityMatchers)
    {
        this.capabilityBindingService = capabilityBindingService;
        if (capabilityMatchers != null)
        {
            this.capabilityMatchers.addAll(Arrays.asList(capabilityMatchers));
        }
    }

    /**
     * Registers capability manager for bind and unbind events
     * 
     * @param capabilityRegistryLookupManager
     *            The capability register service client
     */
    public void register(ICapabilityRegistryLookupManager capabilityRegistryLookupManager)
    {
        ICapabilityProviderRegistrationListener capabilityProviderRegistrationListener = new ICapabilityProviderRegistrationListener()
        {
            @Override
            public void registered(CapabilityProvider capabilityProvider, String s)
            {
                ExecutorService executor = Executors.newSingleThreadExecutor();
                executor.submit(() -> tryBind());
                executor.shutdown();
            }

            @Override
            public void unregistered(CapabilityProvider capabilityProvider, String s)
            {
                ExecutorService executor = Executors.newSingleThreadExecutor();
                executor.submit(() -> tryUnbind(capabilityProvider));
                executor.shutdown();
            }
        };
        capabilityRegistryLookupManager.addCapabilityProviderRegistrationListener(capabilityProviderRegistrationListener);
    }

    private void tryBind()
    {
        try
        {
            bind();
        }
        catch (ServiceTimeoutException | CapabilityRegistryException e)
        {
            LOGGER.warn(HDCRMessageCode.NO_CAPABILITY_PROVIDER_W.getMessageCode());
        }
    }

    private void tryUnbind(CapabilityProvider capabilityProvider)
    {
        try
        {
            unbind(capabilityProvider);
        }
        catch (ServiceTimeoutException | CapabilityRegistryException e)
        {
            LOGGER.warn(HDCRMessageCode.NO_CAPABILITY_PROVIDER_W.getMessageCode());
        }
    }

    /**
     * Binds capabilities
     * 
     * @throws ServiceTimeoutException
     *             Thrown if the request times out.
     * @throws CapabilityRegistryException
     *             Thrown if the request fails.
     */
    public synchronized void bind() throws ServiceTimeoutException, CapabilityRegistryException
    {
        final Map latestBindings = new HashMap<>();

        List capabilities = capabilityBindingService.lookupCapabilities(capabilityMatchers
                .toArray(new CapabilityMatcher[] {}));

        for (CapabilityData capabilityData : capabilities)
        {
            CapabilityBindingKey bindingKey = createCapabilityBindingKey(capabilityData);
            latestBindings.put(bindingKey, capabilityData);

            if (!existingBindings.containsKey(bindingKey))
            {
                existingBindings.put(bindingKey, capabilityData);
                capabilityBindingService.add(capabilityData);
            }
        }

        for (Map.Entry entry : existingBindings.entrySet())
        {
            if (!latestBindings.containsKey(entry.getKey()))
            {
                existingBindings.remove(entry.getKey());
                capabilityBindingService.remove(entry.getValue());
            }
        }
    }

    /**
     * Unbinds a capability
     * 
     * @param provider
     *            The capability provider
     * @throws ServiceTimeoutException
     *             Thrown if the request times out.
     * @throws CapabilityRegistryException
     *             Thrown if the request fails.
     */
    public synchronized void unbind(CapabilityProvider provider) throws ServiceTimeoutException, CapabilityRegistryException
    {
        boolean rebindNeeded = false;

        for (CapabilityMatcher capabilityMatcher : capabilityMatchers)
        {
            List capabilities = capabilityMatcher.match(Arrays.asList(provider));

            for (CapabilityData capabilityData : capabilities)
            {
                CapabilityBindingKey bindingKey = createCapabilityBindingKey(capabilityData);
                if (existingBindings.containsKey(bindingKey))
                {
                    existingBindings.remove(bindingKey);
                    capabilityBindingService.remove(capabilityData);
                    rebindNeeded = true;
                }
            }
        }

        if (rebindNeeded)
        {
            bind();
        }
    }

    public Collection getCurrentCapabilities()
    {
        return new ArrayList<>(existingBindings.values());
    }

    private CapabilityBindingKey createCapabilityBindingKey(CapabilityData capabilityData)
    {
        return new CapabilityBindingKey(capabilityData.getCapability().getProfile(), capabilityData.getProvider().getIdentity()
                .getInstanceId());
    }

    private static final class CapabilityBindingKey
    {
        private String capabilityName;
        private String providerId;

        public CapabilityBindingKey(String capabilityName, String providerId)
        {
            this.capabilityName = capabilityName;
            this.providerId = providerId;
        }

        @Override
        public boolean equals(Object o)
        {
            if (this == o)
            {
                return true;
            }
            if (o == null || getClass() != o.getClass())
            {
                return false;
            }

            CapabilityBindingKey that = (CapabilityBindingKey) o;

            if (capabilityName != null ? !capabilityName.equals(that.capabilityName) : that.capabilityName != null)
            {
                return false;
            }
            return providerId != null ? providerId.equals(that.providerId) : that.providerId == null;

        }

        @Override
        public int hashCode()
        {
            int result = capabilityName != null ? capabilityName.hashCode() : 0;
            result = 31 * result + (providerId != null ? providerId.hashCode() : 0);
            return result;
        }
    }
}