// Copyright (c) Microsoft. All rights reserved. // // This is unpublished source code of Microsoft. // The copyright notice above does not evidence any // actual or intended publication of such source code. // OneLiner : Implementation of MNLBMachine // DevUnit : wlbstest // Author : Murtaza Hakim // History: // -------- // // Revised by : mhakim // Date : 02-09-01 // Reason : clustersetting class no longer has igmpjoininterval // property. // // Revised by : mhakim // Date : 02-14-01 // Reason : The order in which win2k and whistler settings // is done depends on previous state of cluster. // include files #include "MNLBMachine.h" #include "MNLBExe.h" #include "MTrace.h" #include "MNicInfo.h" #include "WTokens.h" #include using namespace std; // constructor // MNLBMachine::MNLBMachine( const _bstr_t& ip, const _bstr_t& clusterIP ) : mIP( ip ), mClusterIP( clusterIP ), p_machine( 0 ) { connectToMachine(); TRACE(MTrace::INFO, L"mnlbmachine constructor\n"); } // constructor for local machine // MNLBMachine::MNLBMachine( const _bstr_t& clusterIP ) : mIP( L"self" ), mClusterIP( clusterIP ), p_machine( 0 ) { connectToMachine(); TRACE(MTrace::INFO, L"mnlbmachine constructor\n"); } // default constructor // // note that default constructor is purposely left undefined. // NO one should be using it. It is declared just for vector class usage. // copy constructor // MNLBMachine::MNLBMachine(const MNLBMachine& objToCopy ) : mIP( objToCopy.mIP ), mClusterIP( objToCopy.mClusterIP ), p_machine( auto_ptr( new MWmiObject( *objToCopy.p_machine ) ) ) { TRACE(MTrace::INFO, L"mnlbsmachine copy constructor\n"); } // assignment operator // MNLBMachine& MNLBMachine::operator=( const MNLBMachine& rhs ) { mIP = rhs.mIP; mClusterIP = rhs.mClusterIP; p_machine = auto_ptr( new MWmiObject( *rhs.p_machine ) ); TRACE(MTrace::INFO, L"mnlbsmachine assignment operator\n"); return *this; } // destructor // MNLBMachine::~MNLBMachine() { TRACE(MTrace::INFO, L"mnlbsmachine destructor\n"); } // getClusterProperties // MNLBMachine::MNLBMachine_Error MNLBMachine::getClusterProperties( ClusterProperties* cp ) { // set parameters to get for win2k // vector parameterStoreWin2k; MWmiParameter ClusterIPAddress(L"ClusterIPAddress"); parameterStoreWin2k.push_back( &ClusterIPAddress ); MWmiParameter ClusterNetworkMask(L"ClusterNetworkMask"); parameterStoreWin2k.push_back( &ClusterNetworkMask ); MWmiParameter ClusterName(L"ClusterName"); parameterStoreWin2k.push_back( &ClusterName ); MWmiParameter ClusteMACAddress(L"ClusterMACAddress"); parameterStoreWin2k.push_back( &ClusteMACAddress ); MWmiParameter MulticastSupportEnabled(L"MulticastSupportEnabled"); parameterStoreWin2k.push_back( &MulticastSupportEnabled ); MWmiParameter RemoteControlEnabled(L"RemoteControlEnabled"); parameterStoreWin2k.push_back( &RemoteControlEnabled ); // set parameters to get for whistler // these properties only present in whistler. // vector parameterStoreWhistler; MWmiParameter IgmpSupport(L"IgmpSupport"); parameterStoreWhistler.push_back( &IgmpSupport ); MWmiParameter ClusterIPToMulticastIP(L"ClusterIPToMulticastIP"); parameterStoreWhistler.push_back( &ClusterIPToMulticastIP ); MWmiParameter MulticastIPAddress(L"MulticastIPAddress"); parameterStoreWhistler.push_back( &MulticastIPAddress ); // Edited( mhakim 02-09-01) // now no longer do we have any igmpjoininterval property. // // MWmiParameter IgmpJoinInterval(L"IgmpJoinInterval"); // parameterStoreWhistler.push_back( &IgmpJoinInterval ); // get instances of clustersetting class. // vector< MWmiInstance > instanceStore; _bstr_t relPath = L"MicrosoftNLB_ClusterSetting.Name=\"" + mClusterIP + L":" + mHostID + L"\""; p_machine->getSpecificInstance( L"MicrosoftNLB_ClusterSetting", relPath, &instanceStore ); // get win2k parameters instanceStore[0].getParameters( parameterStoreWin2k ); // get whistler parameters bool machineIsWhistler = true; try { // this will fail on win2k // as adapterguid, igmpsupport etc are not present. instanceStore[0].getParameters( parameterStoreWhistler ); } catch( _com_error e ) { // maybe it was a win2k machine. This exception is expected, thus catch. // for better safety, need to find exact error code returned and then only do the // folllowing otherwise need to rethrow. // TRACE( MTrace::INFO, L"tried whistler operation on win2k, this is expected\n"); machineIsWhistler = false; } cp->cIP = ClusterIPAddress.getValue(); cp->cSubnetMask = ClusterNetworkMask.getValue(); cp->cFullInternetName = ClusterName.getValue(); cp->cNetworkAddress = ClusteMACAddress.getValue(); cp->multicastSupportEnabled = MulticastSupportEnabled.getValue(); cp->remoteControlEnabled = RemoteControlEnabled.getValue(); if( machineIsWhistler == true ) { cp->igmpSupportEnabled = IgmpSupport.getValue(); cp->clusterIPToMulticastIP = ClusterIPToMulticastIP.getValue(); cp->multicastIPAddress = MulticastIPAddress.getValue(); // Edited( mhakim 02-09-01) // now no longer do we have any igmpjoininterval property. // // cp->igmpJoinInterval = IgmpJoinInterval.getValue(); } return MNLBMachine_SUCCESS; } // getHostProperties // MNLBMachine::MNLBMachine_Error MNLBMachine::getHostProperties( HostProperties* hp ) { // get node properties // vector parameterStoreWin2k; // the status code is to be got from the Node class. // MWmiParameter StatusCode(L"StatusCode"); parameterStoreWin2k.push_back( &StatusCode ); vector< MWmiInstance > instanceStore; _bstr_t relPath = L"MicrosoftNLB_Node.Name=\"" + mClusterIP + L":" + mHostID + L"\""; p_machine->getSpecificInstance( L"MicrosoftNLB_Node", relPath, &instanceStore ); instanceStore[0].getParameters( parameterStoreWin2k ); hp->hostStatus = long( StatusCode.getValue() ); parameterStoreWin2k.erase( parameterStoreWin2k.begin(), parameterStoreWin2k.end() ); instanceStore.erase( instanceStore.begin(), instanceStore.end() ); MWmiParameter DedicatedIPAddress(L"DedicatedIPAddress"); parameterStoreWin2k.push_back( &DedicatedIPAddress ); MWmiParameter DedicatedNetworkMask(L"DedicatedNetworkMask"); parameterStoreWin2k.push_back( &DedicatedNetworkMask ); MWmiParameter HostPriority(L"HostPriority"); parameterStoreWin2k.push_back( &HostPriority ); MWmiParameter ClusterModeOnStart(L"ClusterModeOnStart"); parameterStoreWin2k.push_back( &ClusterModeOnStart ); MWmiParameter Server("__Server"); parameterStoreWin2k.push_back( &Server); // set parameters to get for whistler // these properties only present in whistler. // vector parameterStoreWhistler; MWmiParameter AdapterGuid(L"AdapterGuid"); parameterStoreWhistler.push_back( &AdapterGuid ); // get instances of nodesetting class. // relPath = L"MicrosoftNLB_NodeSetting.Name=\"" + mClusterIP + L":" + mHostID + L"\""; p_machine->getSpecificInstance( L"MicrosoftNLB_NodeSetting", relPath, &instanceStore ); // get win2k parameters. instanceStore[0].getParameters( parameterStoreWin2k ); // get whistler parameters bool machineIsWhistler = true; try { // this will fail on win2k // as adapterguid, igmpsupport etc are not present. instanceStore[0].getParameters( parameterStoreWhistler ); } catch( _com_error e ) { // maybe it was a win2k machine. This exception is expected, thus catch. // for better safety, need to find exact error code returned and then only do the // folllowing otherwise need to rethrow. // TRACE( MTrace::INFO, L"tried whistler operation on win2k, this is expected\n"); machineIsWhistler = false; } hp->hIP = DedicatedIPAddress.getValue(); hp->hSubnetMask = DedicatedNetworkMask.getValue(); hp->hID = HostPriority.getValue(); hp->initialClusterStateActive = ClusterModeOnStart.getValue(); hp->machineName = Server.getValue(); if( machineIsWhistler == true ) { Common::getNLBNicInfoForWhistler( mIP, _bstr_t( AdapterGuid.getValue() ), hp->nicInfo ); } else { Common::getNLBNicInfoForWin2k( mIP, hp->nicInfo ); } return MNLBMachine_SUCCESS; } // setClusterProperties // MNLBMachine::MNLBMachine_Error MNLBMachine::setClusterProperties( const ClusterProperties& cp, unsigned long* retVal ) { // set parameters to set for win2k vector parameterStoreWin2k; MWmiParameter ClusterIPAddress(L"ClusterIPAddress"); ClusterIPAddress.setValue( cp.cIP ); parameterStoreWin2k.push_back( &ClusterIPAddress ); MWmiParameter ClusterNetworkMask(L"ClusterNetworkMask"); ClusterNetworkMask.setValue( cp.cSubnetMask ); parameterStoreWin2k.push_back( &ClusterNetworkMask ); MWmiParameter ClusterName(L"ClusterName"); ClusterName.setValue( cp.cFullInternetName ); parameterStoreWin2k.push_back( &ClusterName ); // mac address cannot be set. MWmiParameter MulticastSupportEnabled(L"MulticastSupportEnabled"); MulticastSupportEnabled.setValue( cp.multicastSupportEnabled ); parameterStoreWin2k.push_back( &MulticastSupportEnabled ); MWmiParameter RemoteControlEnabled(L"RemoteControlEnabled"); RemoteControlEnabled.setValue( cp.remoteControlEnabled ); parameterStoreWin2k.push_back( &RemoteControlEnabled ); // set parameters for whistler. // these properties only for whistler vector parameterStoreWhistler; MWmiParameter IgmpSupport(L"IgmpSupport"); IgmpSupport.setValue( cp.igmpSupportEnabled ); parameterStoreWhistler.push_back( &IgmpSupport ); MWmiParameter ClusterIPToMulticastIP(L"ClusterIPToMulticastIP"); ClusterIPToMulticastIP.setValue( cp.clusterIPToMulticastIP ); parameterStoreWhistler.push_back( &ClusterIPToMulticastIP ); MWmiParameter MulticastIPAddress(L"MulticastIPAddress"); MulticastIPAddress.setValue( cp.multicastIPAddress ); parameterStoreWhistler.push_back( &MulticastIPAddress ); // Edited( mhakim 02-09-01) // now no longer do we have any igmpjoininterval property. // // MWmiParameter IgmpJoinInterval(L"IgmpJoinInterval"); // IgmpJoinInterval.setValue( cp.igmpJoinInterval ); // parameterStoreWhistler.push_back( &IgmpJoinInterval ); vector< MWmiInstance > instanceStore; _bstr_t relPath = L"MicrosoftNLB_ClusterSetting.Name=\"" + mClusterIP + L":" + mHostID + L"\""; p_machine->getSpecificInstance( L"MicrosoftNLB_ClusterSetting", relPath, &instanceStore ); // Edited( mhakim 02-14-01) // // The order in which win2k and whistler operations // need to be done depends on previous state of cluster. // If the previous mode of cluster was unicast, then // you have to do win2k first, whistler next. // If the previous mode was mcast+igmp you have to // do whistler first, win2k next. // If the previous mode was mcast, the order does not // matter. // All this is because you cant have unicast+igmp // together. // find previous cluster mode. ClusterProperties cpPrevious; getClusterProperties( &cpPrevious ); if( cpPrevious.multicastSupportEnabled == false ) { // mode is unicast // set win2k parameters. instanceStore[0].setParameters( parameterStoreWin2k ); // set whistler parameters. try { instanceStore[0].setParameters( parameterStoreWhistler ); } catch( _com_error e ) { // maybe it was a win2k machine. This exception is expected, thus catch. // For better safety, need to match error code returned with expected and then only do the // folllowing otherwise need to rethrow. // TRACE( MTrace::INFO, L"tried whistler operation on win2k, this is expected\n"); } } else { // set whistler parameters. try { instanceStore[0].setParameters( parameterStoreWhistler ); } catch( _com_error e ) { // maybe it was a win2k machine. This exception is expected, thus catch. // For better safety, need to match error code returned with expected and then only do the // folllowing otherwise need to rethrow. // TRACE( MTrace::INFO, L"tried whistler operation on win2k, this is expected\n"); } // set win2k parameters. instanceStore[0].setParameters( parameterStoreWin2k ); } // sync up the driver with these changes. reload( retVal ); mClusterIP = cp.cIP; return MNLBMachine_SUCCESS; } // setHostProperties // MNLBMachine::MNLBMachine_Error MNLBMachine::setHostProperties( const HostProperties& hp, unsigned long* retVal ) { // set node properties // vector parameterStore; MWmiParameter DedicatedIPAddress(L"DedicatedIPAddress"); DedicatedIPAddress.setValue( hp.hIP ); parameterStore.push_back( &DedicatedIPAddress ); MWmiParameter DedicatedNetworkMask(L"DedicatedNetworkMask"); DedicatedNetworkMask.setValue( hp.hSubnetMask ); parameterStore.push_back( &DedicatedNetworkMask ); MWmiParameter HostPriority(L"HostPriority"); HostPriority.setValue( hp.hID ); parameterStore.push_back( &HostPriority ); MWmiParameter ClusterModeOnStart(L"ClusterModeOnStart"); ClusterModeOnStart.setValue( hp.initialClusterStateActive ); parameterStore.push_back( &ClusterModeOnStart ); // get instances of nodesetting class. // vector< MWmiInstance > instanceStore; _bstr_t relPath = L"MicrosoftNLB_NodeSetting.Name=\"" + mClusterIP + L":" + mHostID + L"\""; p_machine->getSpecificInstance( L"MicrosoftNLB_NodeSetting", relPath, &instanceStore ); instanceStore[0].setParameters( parameterStore ); // convert hp.hID into string wchar_t hIDString[Common::BUF_SIZE]; swprintf( hIDString, L"%d", hp.hID ); // sync up the driver with these changes. reload( retVal ); mHostID = hIDString; return MNLBMachine_SUCCESS; } // getPortRulesLoadBalanced // MNLBMachine::MNLBMachine_Error MNLBMachine::getPortRulesLoadBalanced( vector* portsLB ) { vector instanceStore; return getPortRulesLoadBalanced_private( portsLB, &instanceStore ); } // getPortRulesLoadBalanced_private // MNLBMachine::MNLBMachine_Error MNLBMachine::getPortRulesLoadBalanced_private( vector* portsLB, vector* instances ) { _bstr_t myName = mClusterIP + L":" + mHostID; // get port properties. // vector parameterStore; MWmiParameter Name(L"Name"); parameterStore.push_back( &Name ); MWmiParameter StartPort(L"StartPort"); parameterStore.push_back( &StartPort ); MWmiParameter EndPort(L"EndPort"); parameterStore.push_back( &EndPort ); MWmiParameter ProtocolProp(L"Protocol"); parameterStore.push_back( &ProtocolProp ); MWmiParameter EqualLoad(L"EqualLoad"); parameterStore.push_back( &EqualLoad ); MWmiParameter LoadWeight(L"LoadWeight"); parameterStore.push_back( &LoadWeight ); MWmiParameter AffinityProp(L"Affinity"); parameterStore.push_back( &AffinityProp ); MNLBPortRule::Affinity affinity; MNLBPortRule::Protocol trafficToHandle; p_machine->getInstances( L"MicrosoftNLB_PortRuleLoadBalanced", instances ); for( int i = 0; i < instances->size(); ++i ) { (*instances)[i].getParameters( parameterStore ); if( _bstr_t( Name.getValue() ) != myName ) { // this portrule is not for this cluster continue; } switch( long (ProtocolProp.getValue()) ) { case 1: trafficToHandle = MNLBPortRule::tcp; break; case 2: trafficToHandle = MNLBPortRule::udp; break; case 3: trafficToHandle = MNLBPortRule::both; break; default: // bug. TRACE( MTrace::SEVERE_ERROR, "unidentified protocol\n" ); throw _com_error( WBEM_E_UNEXPECTED ); break; } switch( long(AffinityProp.getValue()) ) { case 0: affinity = MNLBPortRule::none; break; case 1: affinity = MNLBPortRule::single; break; case 2: affinity = MNLBPortRule::classC; break; default: // bug. TRACE( MTrace::SEVERE_ERROR, "unidentified affinity\n" ); throw _com_error( WBEM_E_UNEXPECTED ); break; } portsLB->push_back( MNLBPortRuleLoadBalanced(long (StartPort.getValue()), long( EndPort.getValue()), trafficToHandle, bool( EqualLoad.getValue()), long( LoadWeight.getValue()), affinity) ); } return MNLBMachine_SUCCESS; } // getPortRulesFailover // MNLBMachine::MNLBMachine_Error MNLBMachine::getPortRulesFailover( vector* portsF ) { vector instanceStore; return getPortRulesFailover_private( portsF, &instanceStore ); } // getPortRulesFailover_private // MNLBMachine::MNLBMachine_Error MNLBMachine::getPortRulesFailover_private( vector* portsF, vector* instances ) { _bstr_t myName = mClusterIP + L":" + mHostID; // get port properties. // vector parameterStore; MWmiParameter Name(L"Name"); parameterStore.push_back( &Name ); MWmiParameter StartPort(L"StartPort"); parameterStore.push_back( &StartPort ); MWmiParameter EndPort(L"EndPort"); parameterStore.push_back( &EndPort ); MWmiParameter ProtocolProp(L"Protocol"); parameterStore.push_back( &ProtocolProp ); MWmiParameter Priority(L"Priority"); parameterStore.push_back( &Priority ); MNLBPortRule::Protocol trafficToHandle; p_machine->getInstances( L"MicrosoftNLB_PortRuleFailover", instances ); for( int i = 0; i < instances->size(); ++i ) { (*instances)[i].getParameters( parameterStore ); if( _bstr_t( Name.getValue() ) != myName ) { // this portrule is not for this cluster continue; } switch( long (ProtocolProp.getValue()) ) { case 1: trafficToHandle = MNLBPortRule::tcp; break; case 2: trafficToHandle = MNLBPortRule::udp; break; case 3: trafficToHandle = MNLBPortRule::both; break; default: // bug. TRACE( MTrace::SEVERE_ERROR, "unidentified protocol\n" ); throw _com_error( WBEM_E_UNEXPECTED ); break; } portsF->push_back( MNLBPortRuleFailover(long (StartPort.getValue()), long( EndPort.getValue()), trafficToHandle, long( Priority.getValue()) ) ); } return MNLBMachine_SUCCESS; } // getPortRulesDisabled // MNLBMachine::MNLBMachine_Error MNLBMachine::getPortRulesDisabled( vector* portsD ) { vector instanceStore; return getPortRulesDisabled_private( portsD, &instanceStore ); } // getPortRulesDisabled_private // MNLBMachine::MNLBMachine_Error MNLBMachine::getPortRulesDisabled_private( vector* portsD, vector* instances ) { _bstr_t myName = mClusterIP + L":" + mHostID; // get port properties. // vector parameterStore; MWmiParameter Name(L"Name"); parameterStore.push_back( &Name ); MWmiParameter StartPort(L"StartPort"); parameterStore.push_back( &StartPort ); MWmiParameter EndPort(L"EndPort"); parameterStore.push_back( &EndPort ); MWmiParameter ProtocolProp(L"Protocol"); parameterStore.push_back( &ProtocolProp ); MNLBPortRule::Protocol trafficToHandle; p_machine->getInstances( L"MicrosoftNLB_PortRuleDisabled", instances ); for( int i = 0; i < instances->size(); ++i ) { (*instances)[i].getParameters( parameterStore ); if( _bstr_t( Name.getValue() ) != myName ) { // this portrule is not for this cluster continue; } switch( long (ProtocolProp.getValue()) ) { case 1: trafficToHandle = MNLBPortRule::tcp; break; case 2: trafficToHandle = MNLBPortRule::udp; break; case 3: trafficToHandle = MNLBPortRule::both; break; default: // bug. TRACE( MTrace::SEVERE_ERROR, "unidentified protocol\n" ); throw _com_error( WBEM_E_UNEXPECTED ); break; } portsD->push_back( MNLBPortRuleDisabled( long (StartPort.getValue() ), long( EndPort.getValue() ), trafficToHandle ) ); } return MNLBMachine_SUCCESS; } // addPortRuleLoadBalanced // MNLBMachine::MNLBMachine_Error MNLBMachine::addPortRuleLoadBalanced( const MNLBPortRuleLoadBalanced& portRuleLB ) { // set the name as "clusterip:hostid" _bstr_t str; str = mClusterIP + L":" + mHostID; vector instanceParameter; MWmiParameter name(L"Name"); name.setValue( str ); instanceParameter.push_back( &name ); MWmiParameter sp(L"StartPort"); sp.setValue( portRuleLB._startPort ); instanceParameter.push_back( &sp ); MWmiParameter EndPort(L"EndPort"); EndPort.setValue( portRuleLB._endPort ); instanceParameter.push_back( &EndPort ); long protocolValue; MWmiParameter protocol(L"Protocol"); switch( portRuleLB._trafficToHandle ) { case MNLBPortRule::both: protocolValue = 3; protocol.setValue( protocolValue ); break; case MNLBPortRule::tcp: protocolValue = 1; protocol.setValue( protocolValue ); break; case MNLBPortRule::udp: protocolValue = 2; protocol.setValue( protocolValue ); break; default: // bug. TRACE( MTrace::SEVERE_ERROR, "unidentified protocol\n" ); throw _com_error( WBEM_E_UNEXPECTED ); break; } instanceParameter.push_back( &protocol ); MWmiParameter el(L"EqualLoad"); el.setValue( portRuleLB._isEqualLoadBalanced ); instanceParameter.push_back( &el ); MWmiParameter lw(L"LoadWeight"); lw.setValue( portRuleLB._load ); instanceParameter.push_back( &lw ); MWmiParameter affinity(L"Affinity"); long affinityValue; switch( portRuleLB._affinity ) { case MNLBPortRule::none: affinityValue = 0; affinity.setValue(affinityValue); break; case MNLBPortRule::single: affinityValue = 1; affinity.setValue(affinityValue); break; case MNLBPortRule::classC: affinityValue = 2; affinity.setValue(affinityValue); break; default: // bug. TRACE( MTrace::SEVERE_ERROR, "unidentified affinity\n" ); throw _com_error( WBEM_E_UNEXPECTED ); break; } instanceParameter.push_back( &affinity ); p_machine->createInstance( L"MicrosoftNLB_PortRuleLoadBalanced", instanceParameter ); // sync up the driver with these changes. unsigned long retVal; reload( &retVal ); return MNLBMachine_SUCCESS; } // addPortRuleFailover // MNLBMachine::MNLBMachine_Error MNLBMachine::addPortRuleFailover( const MNLBPortRuleFailover& portRuleF ) { // set the name as "clusterip:hostid" _bstr_t str; str = mClusterIP + L":" + mHostID; vector instanceParameter; MWmiParameter name(L"Name"); name.setValue( str ); instanceParameter.push_back( &name ); MWmiParameter sp(L"StartPort"); sp.setValue( portRuleF._startPort ); instanceParameter.push_back( &sp ); MWmiParameter EndPort(L"EndPort"); EndPort.setValue( portRuleF._endPort ); instanceParameter.push_back( &EndPort ); long protocolValue; MWmiParameter protocol(L"Protocol"); switch( portRuleF._trafficToHandle ) { case MNLBPortRule::both: protocolValue = 3; protocol.setValue( protocolValue ); break; case MNLBPortRule::tcp: protocolValue = 1; protocol.setValue( protocolValue ); break; case MNLBPortRule::udp: protocolValue = 2; protocol.setValue( protocolValue ); break; default: TRACE( MTrace::SEVERE_ERROR, "unidentified protocol\n" ); throw _com_error( WBEM_E_UNEXPECTED ); break; } instanceParameter.push_back( &protocol ); MWmiParameter p("Priority"); p.setValue( portRuleF._priority); instanceParameter.push_back( &p ); p_machine->createInstance( L"MicrosoftNLB_PortRuleFailover", instanceParameter ); // sync up the driver with these changes. unsigned long retVal; reload( &retVal ); return MNLBMachine_SUCCESS; } // addPortRuleDisabled // MNLBMachine::MNLBMachine_Error MNLBMachine::addPortRuleDisabled( const MNLBPortRuleDisabled& portRuleD ) { // set the name as "clusterip:hostid" _bstr_t str; str = mClusterIP + L":" + mHostID; vector instanceParameter; MWmiParameter name(L"Name"); name.setValue( str ); instanceParameter.push_back( &name ); MWmiParameter sp(L"StartPort"); sp.setValue( portRuleD._startPort ); instanceParameter.push_back( &sp ); MWmiParameter ep(L"EndPort"); ep.setValue( portRuleD._endPort ); instanceParameter.push_back( &ep ); long protocolValue; MWmiParameter protocol(L"Protocol"); switch( portRuleD._trafficToHandle ) { case MNLBPortRule::both: protocolValue = 3; protocol.setValue( protocolValue ); break; case MNLBPortRule::tcp: protocolValue = 1; protocol.setValue( protocolValue ); break; case MNLBPortRule::udp: protocolValue = 2; protocol.setValue( protocolValue ); break; default: // bug. TRACE( MTrace::SEVERE_ERROR, "unidentified protocol\n" ); throw _com_error( WBEM_E_UNEXPECTED ); break; } instanceParameter.push_back( &protocol ); p_machine->createInstance( L"MicrosoftNLB_PortRuleDisabled", instanceParameter ); // sync up the driver with these changes. unsigned long retVal; reload( &retVal ); return MNLBMachine_SUCCESS; } // removePortRuleLoadBalanced // MNLBMachine::MNLBMachine_Error MNLBMachine::removePortRuleLoadBalanced( const MNLBPortRuleLoadBalanced& portRuleLB ) { _bstr_t myName = mClusterIP + L":" + mHostID; wchar_t startPortBuffer[Common::BUF_SIZE]; swprintf( startPortBuffer, L"%d", portRuleLB._startPort ); vector instanceStorePortRuleLoadBalanced; _bstr_t relPath = L"MicrosoftNLB_PortRuleLoadBalanced.Name=\"" + mClusterIP + L":" + mHostID + L"\"" + L"," + L"StartPort=" + startPortBuffer; p_machine->getSpecificInstance( L"MicrosoftNlb_PortRuleLoadBalanced", relPath, &instanceStorePortRuleLoadBalanced ); p_machine->deleteInstance( instanceStorePortRuleLoadBalanced[0] ); // sync up the driver with these changes. unsigned long retVal; reload( &retVal ); return MNLBMachine_SUCCESS; } // removePortRuleFailover // MNLBMachine::MNLBMachine_Error MNLBMachine::removePortRuleFailover( const MNLBPortRuleFailover& portRuleF ) { _bstr_t myName = mClusterIP + L":" + mHostID; wchar_t startPortBuffer[Common::BUF_SIZE]; swprintf( startPortBuffer, L"%d", portRuleF._startPort ); vector instanceStorePortRuleFailover; _bstr_t relPath = L"MicrosoftNLB_PortRuleFailover.Name=\"" + mClusterIP + L":" + mHostID + L"\"" + L"," + L"StartPort=" + startPortBuffer; p_machine->getSpecificInstance( L"MicrosoftNlb_PortRuleFailover", relPath, &instanceStorePortRuleFailover ); p_machine->deleteInstance( instanceStorePortRuleFailover[0] ); // sync up the driver with these changes. unsigned long retVal; reload( &retVal ); return MNLBMachine_SUCCESS; } // removePortRuleDisabled // MNLBMachine::MNLBMachine_Error MNLBMachine::removePortRuleDisabled( const MNLBPortRuleDisabled& portRuleD ) { _bstr_t myName = mClusterIP + L":" + mHostID; wchar_t startPortBuffer[Common::BUF_SIZE]; swprintf( startPortBuffer, L"%d", portRuleD._startPort ); vector instanceStorePortRuleDisabled; _bstr_t relPath = L"MicrosoftNLB_PortRuleDisabled.Name=\"" + mClusterIP + L":" + mHostID + L"\"" + L"," + L"StartPort=" + startPortBuffer; p_machine->getSpecificInstance( L"MicrosoftNlb_PortRuleDisabled", relPath, &instanceStorePortRuleDisabled ); p_machine->deleteInstance( instanceStorePortRuleDisabled[0] ); // sync up the driver with these changes. unsigned long retVal; reload( &retVal ); return MNLBMachine_SUCCESS; } // start // MNLBMachine::MNLBMachine_Error MNLBMachine::start( int hostID, unsigned long* retVal ) { // get the specific instance to run method on. vector< MWmiInstance > instanceStore; getInstanceToRunMethodOn( hostID, &instanceStore ); MNLBExe::start( instanceStore[0], retVal ); return MNLBMachine_SUCCESS; } // stop // MNLBMachine::MNLBMachine_Error MNLBMachine::stop( int hostID, unsigned long* retVal ) { // get the specific instance to run method on. vector< MWmiInstance > instanceStore; getInstanceToRunMethodOn( hostID, &instanceStore ); MNLBExe::stop( instanceStore[0], retVal ); return MNLBMachine_SUCCESS; } // resume // MNLBMachine::MNLBMachine_Error MNLBMachine::resume( int hostID, unsigned long* retVal ) { // get the specific instance to run method on. vector< MWmiInstance > instanceStore; getInstanceToRunMethodOn( hostID, &instanceStore ); MNLBExe::resume( instanceStore[0], retVal ); return MNLBMachine_SUCCESS; } // suspend // MNLBMachine::MNLBMachine_Error MNLBMachine::suspend( int hostID, unsigned long* retVal ) { // get the specific instance to run method on. vector< MWmiInstance > instanceStore; getInstanceToRunMethodOn( hostID, &instanceStore ); MNLBExe::suspend( instanceStore[0], retVal ); return MNLBMachine_SUCCESS; } // drainstop // MNLBMachine::MNLBMachine_Error MNLBMachine::drainstop( int hostID, unsigned long* retVal ) { // get the specific instance to run method on. vector< MWmiInstance > instanceStore; getInstanceToRunMethodOn( hostID, &instanceStore ); MNLBExe::drainstop( instanceStore[0], retVal ); return MNLBMachine_SUCCESS; } // disable // MNLBMachine::MNLBMachine_Error MNLBMachine::disable( int hostID, unsigned long* retVal, unsigned long portToAffect ) { // get the specific instance to run method on. vector< MWmiInstance > instanceStore; getInstanceToRunMethodOn( hostID, &instanceStore ); MNLBExe::disable( instanceStore[0], retVal, portToAffect ); return MNLBMachine_SUCCESS; } // enable // MNLBMachine::MNLBMachine_Error MNLBMachine::enable( int hostID, unsigned long* retVal, unsigned long portToAffect ) { // get the specific instance to run method on. vector< MWmiInstance > instanceStore; getInstanceToRunMethodOn( hostID, &instanceStore ); MNLBExe::enable( instanceStore[0], retVal, portToAffect ); return MNLBMachine_SUCCESS; } // drain // MNLBMachine::MNLBMachine_Error MNLBMachine::drain( int hostID, unsigned long* retVal, unsigned long portToAffect ) { // get the specific instance to run method on. vector< MWmiInstance > instanceStore; getInstanceToRunMethodOn( hostID, &instanceStore ); MNLBExe::drain( instanceStore[0], retVal, portToAffect ); return MNLBMachine_SUCCESS; } // reload // MNLBMachine::MNLBMachine_Error MNLBMachine::reload( unsigned long* retVal ) { vector instanceStoreClusterSetting; _bstr_t relPath = L"MicrosoftNLB_ClusterSetting.Name=\"" + mClusterIP + L":" + mHostID + L"\""; p_machine->getSpecificInstance( L"MicrosoftNLB_ClusterSetting", relPath, &instanceStoreClusterSetting ); // input parameters are none. // vector inputParameters; // output parameters which are of interest. // vector outputParameters; MWmiParameter returnValue(L"ReturnValue"); outputParameters.push_back( &returnValue ); instanceStoreClusterSetting[0].runMethod( L"LoadAllSettings", inputParameters, outputParameters ); *retVal = ( long ) returnValue.getValue(); return MNLBMachine_SUCCESS; } // getInstanceToRunMethodOn MNLBMachine::MNLBMachine_Error MNLBMachine::getInstanceToRunMethodOn( int hID, vector * instanceStore ) { vector instanceStoreX; _bstr_t relPath; // see if we want to run clusterwide or host specific method. if( hID == Common::ALL_HOSTS ) { // cluster wide relPath = L"MicrosoftNLB_Cluster.Name=\"" + mClusterIP + L"\""; p_machine->getSpecificInstance( L"MicrosoftNLB_Cluster", relPath, &instanceStoreX ); instanceStore->push_back( instanceStoreX[0] ); } else if( hID == Common::THIS_HOST ) { // this host specific relPath = L"MicrosoftNLB_Node.Name=\"" + mClusterIP + L":" + mHostID + L"\""; p_machine->getSpecificInstance( L"MicrosoftNLB_Node", relPath, &instanceStoreX ); instanceStore->push_back( instanceStoreX[0] ); } else { // some other host // convert hID into string wchar_t hostIDBuf[1000]; swprintf( hostIDBuf, L"%d", hID ); relPath = L"MicrosoftNLB_Node.Name=\"" + mClusterIP + L":" + hostIDBuf + L"\""; p_machine->getSpecificInstance( L"MicrosoftNLB_Node", relPath, &instanceStoreX ); instanceStore->push_back( instanceStoreX[0] ); } return MNLBMachine_SUCCESS; } // refreshConnection // MNLBMachine::MNLBMachine_Error MNLBMachine::refreshConnection() { return connectToMachine(); } // connectToMachine // MNLBMachine::MNLBMachine_Error MNLBMachine::connectToMachine() { MTrace* trace = MTrace::Instance(); MTrace::TraceLevel prevLevel = trace->GetLevel(); vector hostPropertiesStore; // basically two operations need to succeed. // 1. Is machine ip specified usable or not. // 2. Is the nic specified bound to nlbs or not. // // connect to machine // if( mIP == _bstr_t( L"self") ) { // we want to connect to self machine. p_machine = auto_ptr< MWmiObject > ( new MWmiObject( L"root\\microsoftnlb") ); } else if( mIP == mClusterIP ) { // connecting to cluster remotely using cluster ip. try { trace->SetLevel( MTrace::NO_TRACE ); p_machine = auto_ptr ( new MWmiObject( mIP, L"root\\microsoftnlb", L"Administrator", L"" ) ); } catch( _com_error e ) { trace->SetLevel( prevLevel ); TRACE(MTrace::INFO, L"connection using clusterip has failed\n" ); // Now we will be using api call wlbs query as situation may be that all hosts in cluster are stopped, and no connection // can be established to cluster ip, or there may be no such cluster and we will throw exception. // // get all hosts participating in cluster. DWORD ret = Common::getHostsInCluster( mClusterIP, &hostPropertiesStore ); if( hostPropertiesStore.size() == 0 ) { // no hosts are in this cluster. Cannot proceed reliably. wstring errString; errString = L"cluster " + wstring( mClusterIP ) + L" reported as having no hosts. Maybe cluster ip is wrong, or remote control is turned off\n"; TRACE( MTrace::SEVERE_ERROR, errString ); throw _com_error( WBEM_E_NOT_FOUND ); } // check if any host has dedicated ip not present // if this is so then object may not function reliably. bool allZero = true; int validHost; for( int i = 0; i < hostPropertiesStore.size(); ++i ) { if( hostPropertiesStore[i].hIP == _bstr_t( L"0.0.0.0" ) ) { // host does not have valid dedicated ip. TRACE( MTrace::SEVERE_ERROR, "a host has no dedicated ip. Some object operations may not work as expected\n"); } else { // not all hosts have dedicated ip not filled in. // keep a track of this host. allZero = false; validHost = i; } } // check if all hosts had invalid dedicated ip. if( allZero == true ) { // all hosts have dedicated ip invalid. TRACE( MTrace::SEVERE_ERROR, "all cluster hosts have dedicated ip 0.0.0.0\n"); throw _com_error( WBEM_E_INVALID_PROPERTY ); } p_machine = auto_ptr( new MWmiObject( hostPropertiesStore[validHost].hIP, L"root\\microsoftnlb", L"Administrator", L"") ); } } else { // we want to connect to remote machine. p_machine = auto_ptr ( new MWmiObject( mIP, L"root\\microsoftnlb", L"Administrator", L"" ) ); } // check if specified cluster ip exists on this machine // and find the host id corresponding to this cluster on this machine. checkClusterIPAndSetHostID(); return MNLBMachine_SUCCESS; } MNLBMachine::MNLBMachine_Error MNLBMachine::checkClusterIPAndSetHostID() { // set parameter to get. // we are interested in name. // vector parameterStore; MWmiParameter Name(L"Name"); parameterStore.push_back( &Name ); // get instances of clustersetting class. // vector< MWmiInstance > instanceStore; bool found = false; int i; p_machine->getInstances( L"Microsoftnlb_ClusterSetting", &instanceStore ); found = false; for( i = 0; i < instanceStore.size(); ++i ) { instanceStore[i].getParameters( parameterStore ); WTokens tok; vector tokens; tok.init( wstring( _bstr_t(Name.getValue()) ), L":" ); tokens = tok.tokenize(); _bstr_t clusterIP = tokens[0].c_str(); mHostID = tokens[1].c_str(); if( mClusterIP == clusterIP ) { // right object found found = true; break; } } if( found == false ) { TRACE( MTrace::SEVERE_ERROR, L"this machine does not have any cluster with specified cluster ip\n"); throw _com_error( WBEM_E_NOT_FOUND ); } return MNLBMachine_SUCCESS; } // getPresentHostsInfo // MNLBMachine::MNLBMachine_Error MNLBMachine::getPresentHostsInfo( vector< MNLBMachine::HostInfo >* hostInfoStore) { vector parameterStore; MWmiParameter Name(L"Name"); parameterStore.push_back( &Name ); MWmiParameter DedicatedIPAddress(L"DedicatedIPAddress"); parameterStore.push_back( &DedicatedIPAddress ); vector< MWmiInstance > instanceStore; p_machine->getInstances( L"MicrosoftNLB_Node", &instanceStore ); for( int i = 0; i < instanceStore.size(); ++i ) { instanceStore[i].getParameters( parameterStore ); // Name is in format of "clusterIP:hostID" // WTokens tok; vector tokens; tok.init( wstring( _bstr_t(Name.getValue()) ), L":" ); tokens = tok.tokenize(); _bstr_t clusterIP = tokens[0].c_str(); if( mClusterIP == clusterIP ) { HostInfo hostInfo; hostInfo.hostID = _wtoi( tokens[1].c_str() ); hostInfo.dedicatedIP = DedicatedIPAddress.getValue(); hostInfoStore->push_back( hostInfo ); } } return MNLBMachine_SUCCESS; } // setPassword // MNLBMachine::MNLBMachine_Error MNLBMachine::setPassword( const _bstr_t& password, unsigned long* retVal ) { // form path _bstr_t relPath = L"MicrosoftNLB_ClusterSetting.Name=\"" + mClusterIP + L":" + mHostID + L"\""; vector instanceStoreClusterSetting; p_machine->getSpecificInstance( L"MicrosoftNLB_ClusterSetting", relPath, &instanceStoreClusterSetting ); // input parameters is password // vector inputParameters; MWmiParameter Password(L"Password"); Password.setValue( password ); inputParameters.push_back( &Password ); // output parameters which are of interest. // none. // vector outputParameters; instanceStoreClusterSetting[0].runMethod( L"SetPassword", inputParameters, outputParameters ); reload( retVal ); return MNLBMachine_SUCCESS; }