cloudstack-issues mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From "ASF GitHub Bot (JIRA)" <j...@apache.org>
Subject [jira] [Commented] (CLOUDSTACK-8832) Update Nuage VSP plugin to work with Nuage VSP release 3.2
Date Fri, 18 Sep 2015 22:14:04 GMT

    [ https://issues.apache.org/jira/browse/CLOUDSTACK-8832?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel&focusedCommentId=14876557#comment-14876557
] 

ASF GitHub Bot commented on CLOUDSTACK-8832:
--------------------------------------------

Github user jburwell commented on a diff in the pull request:

    https://github.com/apache/cloudstack/pull/801#discussion_r39906437
  
    --- Diff: plugins/network-elements/nuage-vsp/src/com/cloud/network/manager/NuageVspManagerImpl.java
---
    @@ -285,60 +507,341 @@ public boolean deleteNuageVspDevice(DeleteNuageVspDeviceCmd cmd)
{
             return responseList;
         }
     
    -    @Override
    -    public boolean configure(String name, Map<String, Object> params) throws ConfigurationException
{
    -        try {
    -            initNuageScheduledTasks();
    -        } catch (Exception ce) {
    -            s_logger.warn("Failed to load NuageVsp configuration properties. Check if
the NuageVsp properties are configured correctly");
    +    private void registerNewNuageVspDevice(ConfigurationVO currentConfig, String registeredNuageVspDevice)
{
    +        if (currentConfig == null) {
    +            ConfigKey<String> configKey = new ConfigKey<String>("Advanced",
String.class, "nuagevsp.cms.id", registeredNuageVspDevice,
    +                    "<ACS Nuage VSP Device ID>:<Allocated VSD CMS ID> - Do
not edit", false);
    +            ConfigurationVO configuration = new ConfigurationVO("management-server",
configKey);
    +            _configDao.persist(configuration);
    +        } else {
    +            String newValue;
    +            String currentValue = currentConfig.getValue();
    +            if (StringUtils.isNotBlank(currentValue)) {
    +                newValue = currentValue + ";" + registeredNuageVspDevice;
    +            } else {
    +                newValue = registeredNuageVspDevice;
    +            }
    +            _configDao.update("nuagevsp.cms.id", newValue);
             }
    -        return true;
         }
     
    -    private void initNuageScheduledTasks() {
    -        Integer numOfSyncThreads = Integer.valueOf(_configDao.getValue(NuageVspManager.NuageVspSyncWorkers.key()));
    -        Integer syncUpIntervalInMinutes = Integer.valueOf(_configDao.getValue(NuageVspManager.NuageVspSyncInterval.key()));
    -
    -        if (numOfSyncThreads != null && syncUpIntervalInMinutes != null) {
    -            ThreadFactory threadFactory = new ThreadFactory() {
    -                public Thread newThread(Runnable runnable) {
    -                    Thread thread = new Thread(runnable, "Nuage Vsp sync task");
    -                    if (thread.isDaemon())
    -                        thread.setDaemon(false);
    -                    if (thread.getPriority() != Thread.NORM_PRIORITY)
    -                        thread.setPriority(Thread.NORM_PRIORITY);
    -                    return thread;
    +    private void auditHost(HostVO host) {
    +        _hostDao.loadDetails(host);
    +
    +        boolean validateDomains = true;
    +        List<NuageVspDeviceVO> nuageVspDevices = _nuageVspDao.listByHost(host.getId());
    +        if (!CollectionUtils.isEmpty(nuageVspDevices)) {
    +            for (NuageVspDeviceVO nuageVspDevice : nuageVspDevices) {
    +                ConfigurationVO cmsIdConfig = _configDao.findByName("nuagevsp.cms.id");
    +                String nuageVspCmsId = findNuageVspCmsIdForDevice(nuageVspDevice.getId(),
cmsIdConfig);
    +                SyncNuageVspCmsIdCommand syncCmd = new SyncNuageVspCmsIdCommand(SyncType.AUDIT,
nuageVspCmsId);
    +                SyncNuageVspCmsIdAnswer answer = (SyncNuageVspCmsIdAnswer) _agentMgr.easySend(nuageVspDevice.getHostId(),
syncCmd);
    +
    +                if (answer != null && !answer.getSuccess()) {
    +                    s_logger.fatal("Nuage VSP Device with ID " + nuageVspDevice.getId()
+ " is configured with an unknown CMS ID!");
    +                    validateDomains = false;
    +                } else if (answer != null && answer.getSyncType() == SyncType.REGISTER)
{
    +                    registerNewNuageVspDevice(cmsIdConfig, nuageVspDevice.getId() + ":"
+ answer.getNuageVspCmsId());
                     }
    -            };
    -            scheduler = Executors.newScheduledThreadPool(numOfSyncThreads, threadFactory);
    -            scheduler.scheduleWithFixedDelay(new NuageVspSyncTask("FLOATING_IP"), ONE_MINUTE_MULTIPLIER
* 15, ONE_MINUTE_MULTIPLIER * syncUpIntervalInMinutes,
    -                    TimeUnit.MILLISECONDS);
    -            scheduler.scheduleWithFixedDelay(new NuageVspSyncTask("ENTERPRISE_NTWK_MACRO"),
ONE_MINUTE_MULTIPLIER * 15, ONE_MINUTE_MULTIPLIER * syncUpIntervalInMinutes,
    -                    TimeUnit.MILLISECONDS);
    -            scheduler
    -                    .scheduleWithFixedDelay(new NuageVspSyncTask("ENTERPRISE"), ONE_MINUTE_MULTIPLIER
* 15, ONE_MINUTE_MULTIPLIER * syncUpIntervalInMinutes, TimeUnit.MILLISECONDS);
    -        } else {
    -            s_logger.warn("NuageVsp configuration for syncWorkers=" + numOfSyncThreads
+ " syncInterval=" + syncUpIntervalInMinutes
    -                    + " could not be read properly. So, check if the properties are configured
properly in global properties");
    +            }
    +        }
    +
    +        if (validateDomains) {
    +            auditDomainsOnVsp(host, true, false);
             }
         }
     
    -    public class NuageVspSyncTask implements Runnable {
    +    private boolean auditDomainsOnVsp(HostVO host, boolean add, boolean remove) {
    +        List<NuageVspDeviceVO> nuageVspDevices = _nuageVspDao.listByHost(host.getId());
    +        if (!CollectionUtils.isEmpty(nuageVspDevices)) {
    +            _hostDao.loadDetails(host);
    +            List<DomainVO> allDomains = _domainDao.listAll();
    +            for (DomainVO domain : allDomains) {
    +                try {
    +                    SyncDomainCommand cmd = new SyncDomainCommand(domain.getUuid(), domain.getName(),
domain.getPath(), add, remove);
    +                    SyncDomainAnswer answer = (SyncDomainAnswer) _agentMgr.easySend(host.getId(),
cmd);
    +                    return answer.getSuccess();
    +                } catch (Exception e) {
    +                    s_logger.warn(e.getMessage());
    +                    return false;
    +                }
    +            }
    +        }
    +        return true;
    +    }
     
    -        private String nuageVspEntity;
    +    private String findNuageVspCmsIdForDevice(long deviceId, ConfigurationVO cmsIdConfig)
{
    +        String configValue = cmsIdConfig.getValue();
    +        if (StringUtils.isNotBlank(configValue)) {
    +            String[] configuredNuageVspDevices = configValue.split(";");
    +            for (String configuredNuageVspDevice : configuredNuageVspDevices) {
    +                if (configuredNuageVspDevice.startsWith(deviceId + ":")) {
    +                    return configuredNuageVspDevice.split(":")[1];
    +                }
    +            }
    +        }
    +        return null;
    +    }
     
    -        public NuageVspSyncTask(String nuageVspEntity) {
    -            this.nuageVspEntity = nuageVspEntity;
    +    public List<String> getDnsDetails(Network network) {
    +        List<String> dnsServers = null;
    +        Boolean configureDns = Boolean.valueOf(_configDao.getValue(NuageVspManager.NuageVspConfigDns.key()));
    +        if (configureDns) {
    +            Boolean configureExternalDns = Boolean.valueOf(_configDao.getValue(NuageVspManager.NuageVspDnsExternal.key()));
    +            DataCenterVO dc = _dataCenterDao.findById(network.getDataCenterId());
    +            dnsServers = new ArrayList<String>();
    +            if (configureExternalDns) {
    +                if (dc.getDns1() != null && dc.getDns1().length() > 0) {
    +                    dnsServers.add(dc.getDns1());
    +                }
    +                if (dc.getDns2() != null && dc.getDns2().length() > 0) {
    +                    dnsServers.add(dc.getDns2());
    +                }
    +            } else {
    +                if (dc.getInternalDns1() != null && dc.getInternalDns1().length()
> 0) {
    +                    dnsServers.add(dc.getInternalDns1());
    +                }
    +                if (dc.getInternalDns2() != null && dc.getInternalDns2().length()
> 0) {
    +                    dnsServers.add(dc.getInternalDns2());
    +                }
    +            }
             }
    +        return dnsServers;
    +    }
     
    -        public String getNuageVspEntity() {
    -            return nuageVspEntity;
    +    public List<String> getGatewaySystemIds() {
    +        List<String> gatewayIds = null;
    +        String gatewaySystemIds = String.valueOf(_configDao.getValue(NuageVspManager.NuageVspConfigGateway.key()));
    +        if (StringUtils.isNotBlank(gatewaySystemIds)) {
    +            StringTokenizer tokens = new StringTokenizer(gatewaySystemIds, ",");
    +            gatewayIds = new ArrayList<String>(tokens.countTokens());
    +            while (tokens.hasMoreTokens())
    +            {
    +                gatewayIds.add(tokens.nextToken());
    +            }
             }
    +        return gatewayIds;
    +    }
    +
    +    @Override
    +    public boolean preStateTransitionEvent(Status oldState, Status.Event event, Status
newState, Host host, boolean status, Object opaque) {
    +        return true;
    +    }
     
    -        @Override
    -        public void run() {
    -            nuageVspSync.syncWithNuageVsp(nuageVspEntity);
    +    @Override
    +    public boolean postStateTransitionEvent(StateMachine2.Transition<Status, Status.Event>
transition, Host vo, boolean status, Object opaque) {
    +        // Whenever a Nuage VSP Host comes up, check if all CS domains are present and
check if the CMS ID is valid
    +        if (transition.getToState() == Status.Up && vo instanceof HostVO) {
    +            auditHost((HostVO) vo);
             }
    +        return true;
    +    }
    +
    +    @Override
    +    public boolean configure(String name, Map<String, Object> params) throws ConfigurationException
{
    +        initMessageBusListeners();
    +        initNuageVspResourceListeners();
    +        initNuageNetworkOffering();
    +        initNuageVspVpcOffering();
    +        Status.getStateMachine().registerListener(this);
    +        return true;
    +    }
    +
    +    @DB
    +    private void initMessageBusListeners() {
    +        // Create corresponding enterprise and profile in VSP when creating a CS Domain
    +        _messageBus.subscribe(DomainManager.MESSAGE_ADD_DOMAIN_EVENT, new MessageSubscriber()
{
    +            @Override
    +            public void onPublishMessage(String senderAddress, String subject, Object
args) {
    +                Long domainId = (Long) args;
    +                Domain domain = _domainDao.findById(domainId);
    +
    +                try {
    +                    _domainDao.acquireInLockTable(domain.getId());
    +
    +                    List<NuageVspDeviceVO> nuageVspDevices = _nuageVspDao.listAll();
    +                    for (NuageVspDeviceVO nuageVspDevice : nuageVspDevices) {
    +                        HostVO host = findNuageVspHost(nuageVspDevice.getHostId());
    +                        SyncDomainCommand cmd = new SyncDomainCommand(domain.getUuid(),
domain.getName(), domain.getPath(), true, false);
    +                        _agentMgr.easySend(host.getId(), cmd);
    +                    }
    +                } catch (Exception e) {
    +                    s_logger.error(e.getMessage());
    +                } finally {
    +                    _domainDao.releaseFromLockTable(domain.getId());
    +                }
    +            }
    +        });
    +
    +        // Delete corresponding enterprise and profile in VSP when deleting a CS Domain
    +        _messageBus.subscribe(DomainManager.MESSAGE_REMOVE_DOMAIN_EVENT, new MessageSubscriber()
{
    +            @Override
    +            public void onPublishMessage(String senderAddress, String subject, Object
args) {
    +                DomainVO domain = (DomainVO) args;
    +                try {
    +                    List<NuageVspDeviceVO> nuageVspDevices = _nuageVspDao.listAll();
    +                    for (NuageVspDeviceVO nuageVspDevice : nuageVspDevices) {
    +                        HostVO host = findNuageVspHost(nuageVspDevice.getHostId());
    +                        SyncDomainCommand cmd = new SyncDomainCommand(domain.getUuid(),
domain.getName(), domain.getPath(), false, true);
    +                        _agentMgr.easySend(host.getId(), cmd);
    +                    }
    +                } catch (Exception e) {
    +                    s_logger.error(e.getMessage());
    +                }
    +            }
    +        });
    +    }
    +
    +    @DB
    +    private void initNuageVspResourceListeners() {
    +        _agentMgr.registerForHostEvents(new Listener() {
    +            @Override
    +            public boolean processAnswers(long agentId, long seq, Answer[] answers) {
    +                return true;
    +            }
    +
    +            @Override
    +            public boolean processCommands(long agentId, long seq, Command[] commands)
{
    +                if (commands != null && commands.length == 1) {
    +                    Command command = commands[0];
    +                    if (command instanceof PingNuageVspCommand) {
    +                        PingNuageVspCommand pingNuageVspCommand = (PingNuageVspCommand)
command;
    +                        if (pingNuageVspCommand.shouldAudit()) {
    +                            Host host = _hostDao.findById(pingNuageVspCommand.getHostId());
    +                            auditHost((HostVO) host);
    +                        }
    +                    }
    +                }
    +                return true;
    +            }
    +
    +            @Override
    +            public AgentControlAnswer processControlCommand(long agentId, AgentControlCommand
cmd) {
    +                return null;
    +            }
    +
    +            @Override
    +            public void processConnect(Host host, StartupCommand cmd, boolean forRebalance)
throws ConnectionException {
    +
    +            }
    +
    +            @Override
    +            public boolean processDisconnect(long agentId, Status state) {
    +                return true;
    +            }
    +
    +            @Override
    +            public boolean isRecurring() {
    +                return false;
    +            }
    +
    +            @Override
    +            public int getTimeout() {
    +                return 0;
    +            }
    +
    +            @Override
    +            public boolean processTimeout(long agentId, long seq) {
    +                return true;
    +            }
    +        }, false, true, false);
    +    }
    +
    +    @DB
    +    private void initNuageNetworkOffering() {
    +        Transaction.execute(new TransactionCallbackNoReturn() {
    +            @Override
    +            public void doInTransactionWithoutResult(TransactionStatus status) {
    +                if (_networkOfferingDao.findByUniqueName(nuageVspSharedNetworkOfferingWithSGServiceName)
== null) {
    +                    NetworkOfferingVO defaultNuageVspSharedSGNetworkOffering =
    +                            new NetworkOfferingVO(nuageVspSharedNetworkOfferingWithSGServiceName,
"Offering for NuageVsp Shared Security group enabled networks",
    +                                    Networks.TrafficType.Guest, false, false, null, null,
true, NetworkOffering.Availability.Optional, null, Network.GuestType.Shared, true, true, false,
false, false);
    +
    +                    defaultNuageVspSharedSGNetworkOffering.setState(NetworkOffering.State.Enabled);
    +                    defaultNuageVspSharedSGNetworkOffering = _networkOfferingDao.persistDefaultNetworkOffering(defaultNuageVspSharedSGNetworkOffering);
    +
    +                    Map<Network.Service, Network.Provider> defaultNuageVspSharedSGNetworkOfferingProviders
= new HashMap<Network.Service, Network.Provider>();
    +                    defaultNuageVspSharedSGNetworkOfferingProviders.put(Network.Service.Dhcp,
Network.Provider.NuageVsp);
    +                    defaultNuageVspSharedSGNetworkOfferingProviders.put(Network.Service.SecurityGroup,
Network.Provider.NuageVsp);
    +                    defaultNuageVspSharedSGNetworkOfferingProviders.put(Network.Service.Connectivity,
Network.Provider.NuageVsp);
    +
    +                    for (Network.Service service : defaultNuageVspSharedSGNetworkOfferingProviders.keySet())
{
    +                        NetworkOfferingServiceMapVO offService =
    +                                new NetworkOfferingServiceMapVO(defaultNuageVspSharedSGNetworkOffering.getId(),
service, defaultNuageVspSharedSGNetworkOfferingProviders.get(service));
    +                        _networkOfferingServiceMapDao.persist(offService);
    +                        s_logger.trace("Added service for the NuageVsp network offering:
" + offService);
    +                    }
    +                }
    +            }
    +        });
    +    }
    +
    +    @DB
    +    private void initNuageVspVpcOffering() {
    +        //configure default Nuage VSP vpc offering
    +        Transaction.execute(new TransactionCallbackNoReturn() {
    +            @Override
    +            public void doInTransactionWithoutResult(TransactionStatus status) {
    +                if (_vpcOffDao.findByUniqueName(nuageVPCOfferingName) == null) {
    +                    s_logger.debug("Creating default Nuage VPC offering " + nuageVPCOfferingName);
    +
    +                    Map<Network.Service, Set<Network.Provider>> svcProviderMap
= new HashMap<Network.Service, Set<Network.Provider>>();
    +                    Set<Network.Provider> nuageProviders = new HashSet<Network.Provider>();
    +                    nuageProviders.add(Network.Provider.NuageVsp);
    +                    svcProviderMap.put(Network.Service.Connectivity, nuageProviders);
    --- End diff --
    
    Replace lines 789-791 with ``com.google.common.collect.Sets.newHashSet()``


> Update Nuage VSP plugin to work with Nuage VSP release 3.2
> ----------------------------------------------------------
>
>                 Key: CLOUDSTACK-8832
>                 URL: https://issues.apache.org/jira/browse/CLOUDSTACK-8832
>             Project: CloudStack
>          Issue Type: Improvement
>      Security Level: Public(Anyone can view this level - this is the default.) 
>          Components: Management Server
>    Affects Versions: 4.6.0
>            Reporter: Nick Livens
>            Assignee: Nick Livens
>
> Nuage VSP 3.2 is being released, we want to bring the plugin up to date for this release



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)

Mime
View raw message