Exemplo n.º 1
0
def p_heart_beat_timer():
    global g_clc_ip
    global g_cc_ip
    if g_clc_ip!=None and g_cc_ip!=None:
        OpenLdap.p_all_heart_beat(g_clc_ip,g_cc_ip,'cluster')
    heart = threading.Timer(HEART_BEAT_INTV , p_heart_beat_timer)
    heart.start()
Exemplo n.º 2
0
 def luhya_clc_start_vm(self, clientInfo):
     """ harrison
     远程模式(clientData.is_local==False):
         直接调用ClcThriftServer API luhya_clc_start_vm(clientData)启动虚拟机
     本地模式(clientData.is_local==True):
         调用本地NcThriftServer API luhya_res_start_vm (clientData)启动虚拟机
     """
     ret = -1
     if clientInfo.instance_state.is_local:
         local_nc_ip = utility.get_local_publicip()
         if local_nc_ip != None:
             ret = OpenLdap.p_nc_start_vm(local_nc_ip, clientInfo)
         else:
             logger.debug("get local ip is error!")
     else:
         ldap_ip = utility.get_real_ldap()
         if ldap_ip != None:
             clc_ip = OpenLdap.get_clc_ip(ldap_ip)
             if clc_ip != None:
                 ret = OpenLdap.clc_start_vm(clc_ip, clientInfo)
             else:
                 logger.debug("get real clc ip is error!")
         else:
             logger.debug("get real ldap ip is error!")
     return ret
Exemplo n.º 3
0
def p_dispatch_nodes():
    nodeIp = None
    ldap_ip = utility.get_ldap_server()
    clusterInfo = OpenLdap.p_get_clusterInfo_by_ccIp(ldap_ip,g_cc_ip)
    if clusterInfo!=None:
        nodes = OpenLdap.p_get_nodeInfo_by_clusterName(ldap_ip,clusterInfo.clusterName)
        if nodes!=None and len(nodes)>0:
            nodeIp = nodes[0].hostIp
    return nodeIp
Exemplo n.º 4
0
def p_nc_heart_beat_isAlive():
    logger.debug('p_nc_heart_beat_isAlive()')
    global g_nc_heart_beat
    heartT = time.time()
    for ip in g_nc_heart_beat:
        if (heartT - g_nc_heart_beat[ip]) < 4:
            logger.debug('NC %s is alive' % ip)
        else:
            logger.debug('NC %s is dead!!!' % ip)
            if g_clc_ip!=None:
                OpenLdap.luhya_nc_dead(g_clc_ip,ip,thd_SERVICE_TYPE.CLOUD_NC)
    heart = threading.Timer(4.0,p_nc_heart_beat_isAlive)
    heart.start()
Exemplo n.º 5
0
 def run(self):
     logger.info('p_transmit_server_source_thread...')
     while True:
         if g_wal_ip!=None and g_clc_ip!=None:                        
             hdSource = utility.utility_get_current_resource()
             g_source_switch.acquire()
             hdSource.net_receiverate = g_server_resource['recvRate']
             hdSource.net_sendrate = g_server_resource['sendRate']
             hdSource.cpu_utilization = g_server_resource['cpuUtilization']
             g_source_switch.release()
             hdSource.state = 'HW_STATUS_OK'
             if hdSource.cpu_utilization > VM_CPU_UTILIZATION:
                 hdSource.state = 'HW_STATUS_WARN'            
             OpenLdap.p_transmit_hard_source(g_clc_ip,g_wal_ip,hdSource)
         time.sleep(SERVER_SOURCE_INTV)
Exemplo n.º 6
0
 def run(self):
     while True:
         time.sleep(INSTANCE_REPORT_INTV)
         logger.debug('p_transmit_transcationlist_thread:%s' %str(g_cc_transaction))
         for nodeIp in g_cc_transaction.keys() :
             g_transaction_switch.acquire()
             transactions = g_cc_transaction[nodeIp][:]
             g_transaction_switch.release()
             logger.debug('p_transmit_transcationlist_thread transaction : %s' %str(transactions))
             if g_clc_ip != None:
                 transmitData = thd_transmit_data()
                 transmitData.node_ip = nodeIp
                 transmitData.transactions = transactions
                 logger.debug('p_transmit_transcationlist_thread transmitData:%s: ' %str(transmitData))
                 OpenLdap.p_set_transmit_transactionlist(g_clc_ip,transmitData)
Exemplo n.º 7
0
 def run(self):
     logger.debug('p_get_nodeInfo_byClusterName_thread start ....')
     global g_nc_heart_beat
     while True:
         ldap_ip = utility.get_ldap_server()
         ret = OpenLdap.p_is_register(ldap_ip,thd_SERVICE_TYPE.CLOUD_CC,utility.get_local_publicip())
         if ret:
             clusterInfo = OpenLdap.p_get_clusterInfo_by_ccIp(ldap_ip,g_cc_ip)
             if clusterInfo != None:
                 nodeList = OpenLdap.p_get_nodeInfo_by_clusterName(ldap_ip,clusterInfo.clusterName)
                 if nodeList != None:
                     for nodeInfo in nodeList:
                         g_nc_heart_beat[nodeInfo.hostIp] = time.time()
                     break
         time.sleep(HEART_BEAT_INTV)
         logger.debug('waiting in p_get_nodeInfo_byClusterName_thread()!!!')
Exemplo n.º 8
0
 def run(self):
     while True:
         hostIp = utility.get_local_publicip()
         ldap_ip = utility.get_ldap_server()
         ret = OpenLdap.p_is_register(ldap_ip,thd_SERVICE_TYPE.CLOUD_WALRUS,hostIp)
         if ret:
             logger.info('g_WalrusThriftServer_main_interface running ...')
             handler = walrusApiHandler()
             processor = walrusApi.Processor(handler)
             
             transport = TSocket.TServerSocket(hostIp,thd_port.THRIFT_WALRUS_PORT)
             tfactory = TTransport.TBufferedTransportFactory()
             pfactory = TBinaryProtocol.TBinaryProtocolFactory()
     
             #server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
     
             # You could do one of these for a multithreaded server
             #server = TServer.TThreadedServer(processor, transport, tfactory, pfactory)
             server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory)
     
             logger.info('Starting the server...')
             server.serve()
             logger.error('thrift server done')
             break
         else:
             time.sleep(2)   
Exemplo n.º 9
0
    def run(self):
        while True:
            hostIp = utility.get_local_publicip()
            logger.info( 'g_ClusterThriftServer_main_interface cc register :%s ' %hostIp)
            ldap_ip = utility.get_ldap_server()
            # avoid the ip address cant be read
            if ldap_ip!=None:
                ret = OpenLdap.p_is_register(ldap_ip,thd_SERVICE_TYPE.CLOUD_CC,hostIp)
                if ret:
                    logger.info('g_ClusterThriftServer_main_interface running ...')
                    handler = clusterApiHandler()
                    processor = clusterApi.Processor(handler)
                    transport = TSocket.TServerSocket(hostIp, thd_port.THRIFT_CC_PORT)
                    tfactory = TTransport.TBufferedTransportFactory()
                    pfactory = TBinaryProtocol.TBinaryProtocolFactory()

                    #server = TServer.TSimpleServer(processor, transport, tfactory, pfactory)
                    
                    # You could do one of these for a multithreaded server
                    #server = TServer.TThreadedServer(processor, transport, tfactory, pfactory)
                    server = TServer.TThreadPoolServer(processor, transport, tfactory, pfactory)

                    logger.info('Starting cluster the server...')
                    server.serve()
                    logger.error('thrift cluster server quit!')
                    break
                else:
                    time.sleep(DEFAULT_DELAY)
            else:
                time.sleep(DEFAULT_DELAY)
Exemplo n.º 10
0
 def run(self):
     while True:
         logger.info('p_get_ip_thread...start')
         global g_clc_ip
         global g_wal_ip
         
         g_wal_ip = utility.get_local_publicip()
         ldap_ip = utility.get_ldap_server()
         ret = OpenLdap.p_is_register(ldap_ip,thd_SERVICE_TYPE.CLOUD_WALRUS,g_wal_ip)
         if ret:  
             g_clc_ip = OpenLdap.get_clc_ip(ldap_ip)
         if (g_clc_ip != None) and (g_wal_ip != None):
             break
         else:
             logger.info('p_get_ip_thread()')
         time.sleep(1)
Exemplo n.º 11
0
def p_register_cluster():
    hostIp = utility.get_local_publicip()
    while True:
        ldap_ip = utility.get_ldap_server()
        # avoid the ip address cant be read
        if ldap_ip!=None:
            clusterInfo = OpenLdap.p_get_clusterInfo_by_ccIp(ldap_ip,hostIp)
            if clusterInfo!=None:
                if clusterInfo.clusterName==None :
                    ccName = p_get_cc_name_conf()
                    if ccName!=None:
                        OpenLdap.p_register_cluster(ldap_ip,ccName,hostIp)
                    else:
                        break
                else:
                    break
        time.sleep(DEFAULT_DELAY)
Exemplo n.º 12
0
 def run(self):
     while True:
         walrusIp = utility.get_local_publicip()
         if walrusIp!=None:
             ldap_ip = utility.get_ldap_server()
             ret = OpenLdap.p_init_walrus_info(ldap_ip,walrusIp)
             if ret:
                 break
         time.sleep(1)                
Exemplo n.º 13
0
 def run(self):
     while True:
         ldap_ip = utility.get_ldap_server()
         ret = OpenLdap.p_is_register(ldap_ip,thd_SERVICE_TYPE.CLOUD_WALRUS,utility.get_local_publicip())
         if ret:
             logger.debug('p_heart_beat_thread start ...')
             p_heart_beat_timer()
             break
         else:
             time.sleep(2)
Exemplo n.º 14
0
 def run(self):
     while True:
         ldap_ip = utility.get_ldap_server()
         ret = OpenLdap.p_is_register(ldap_ip,thd_SERVICE_TYPE.CLOUD_CC,utility.get_local_publicip())
         if ret: 
             p_nc_heart_beat_isAlive()
             p_heart_beat_timer()
             break
         else:
             time.sleep(DEFAULT_DELAY)
Exemplo n.º 15
0
 def run(self):    
     while True:
         logger.debug('p_get_ip_thread...start')
         global g_clc_ip
         global g_cc_ip
         
         g_cc_ip = utility.get_local_publicip()
         ldap_ip = utility.get_ldap_server()
         # avoid the ip address cant be read
         if ldap_ip!=None:
             ret = OpenLdap.p_is_register(ldap_ip,thd_SERVICE_TYPE.CLOUD_CC,g_cc_ip)
             if ret:
                 ldap_ip =  utility.get_ldap_server()   
                 g_clc_ip = OpenLdap.get_clc_ip(ldap_ip)
             if (g_clc_ip != None)  and (g_cc_ip != None):
                 logger.info('g_cc_ip:%s,g_clc_ip:%s' %(g_cc_ip,g_clc_ip))               
                 break
             else:
                 logger.debug('waiting in p_get_ip_thread()!!!')
         time.sleep(DEFAULT_DELAY)
Exemplo n.º 16
0
def p_nc_heart_beat(ncIp):
    global g_nc_heart_beat
    ret = True
    if not g_nc_heart_beat.has_key(ncIp):
        ldap_ip = utility.get_ldap_server()
        re = OpenLdap.p_is_register(ldap_ip,thd_SERVICE_TYPE.CLOUD_NC,ncIp)
        if re:
            g_nc_heart_beat[ncIp] = time.time()
        else:
            ret = False
    else:
        g_nc_heart_beat[ncIp] = time.time()
    return ret
Exemplo n.º 17
0
 def luhya_clc_stop_vm(self, clientInfo):
     """ harrison
        如果是在线并且是远程模式:
             转发调用ClcThriftServer API luhya_clc_stop_vm(client_info)停止虚拟机
        如果是在线本地模式或离线模式:
             直接调用NcThriftServer API luhya_nc_stop_vm(client_info)停止虚拟机
     """
     ret = False
     if clientInfo.instance_state.is_local:
         local_nc_ip = utility.get_local_publicip()
         if local_nc_ip != None:
             ret = OpenLdap.p_nc_stop_vm(local_nc_ip, clientInfo)
     else:
         ldap_ip = utility.get_real_ldap()
         if ldap_ip != None:
             clc_ip = OpenLdap.get_clc_ip(ldap_ip)
             if clc_ip != None:
                 ret = OpenLdap.clc_stop_vm(clc_ip, clientInfo)
             else:
                 logger.debug("get real clc ip is error!")
         else:
             logger.debug("get real ldap ip is error!")
     return ret
Exemplo n.º 18
0
 def run(self):
     logger.debug('p_transmit_server_source_thread...')
     global g_nc_source
     global g_cc_ip
     global g_clc_ip
     while True:                        
         hdSource = utility.utility_get_current_resource()
         g_source_switch.acquire()
         hdSource.net_receiverate = g_server_resource['recvRate']
         hdSource.net_sendrate = g_server_resource['sendRate']
         hdSource.cpu_utilization = g_server_resource['cpuUtilization']
         g_source_switch.release()
         hdSource.state = 'HW_STATUS_OK'
         if hdSource.cpu_utilization > VM_CPU_UTILIZATION:
             hdSource.state = 'HW_STATUS_WARN'
         if g_cc_ip!=None:    
             g_nc_source[g_cc_ip] = hdSource
         logger.info(g_nc_source)
         nc_source = g_nc_source.copy()
         for ip in nc_source:
             if g_clc_ip!=None:
                 OpenLdap.p_transmit_hard_source(g_clc_ip,ip,nc_source[ip])
         time.sleep(SERVER_SOURCE_INTV)
Exemplo n.º 19
0
def p_start_vm(clientInfo):
    nodeIp = None
    ret = 0
    if clientInfo.is_assign_node!=None and clientInfo.is_assign_node:
        nodeIp = clientInfo.node_ip
    else:
        nodeIp = p_dispatch_nodes()
    if nodeIp!=None:
        logger.debug('p_start_vm node:%s' %nodeIp)
        ret = OpenLdap.p_nc_start_vm(nodeIp,clientInfo)
    else:
        ret = -7
    retInfo = thd_run_instance_ret()
    retInfo.node_ip = nodeIp
    retInfo.return_value = ret
    logger.debug('p_start_vm the return value:%s' %str(retInfo))
    return retInfo
Exemplo n.º 20
0
def _is_online():
    ret = False
    ldap_ip = utility.get_ldap_server()
    if ldap_ip != None:
        ret = OpenLdap.p_ldap_online(ldap_ip)
    return ret
Exemplo n.º 21
0
def p_get_client_data(user, requestIp):
    client_infos = []
    if _is_online():
        logger.info("real clc is online")
        local_ip = utility.get_local_publicip()
        if local_ip != None:
            real_ldap_ip = utility.get_real_ldap()
            logger.info("real ldap ip:%s" % real_ldap_ip)
            if real_ldap_ip != None:
                clc_ip = OpenLdap.get_clc_ip(real_ldap_ip)
                client_infos = OpenLdap.get_client_data(clc_ip, user, local_ip)
                realUser = user
                if user != "super":
                    _save_client_infos(user, client_infos)
                else:
                    realUser = "******"
                # update local instance state
                instances = OpenLdap.get_instance_states(local_ip, realUser)

                for client_info in client_infos:
                    if user == "super" and client_info.node_ip == local_ip:
                        client_info.run_as_super = True
                    else:
                        client_info.run_as_super = False
                    find_client_info = False
                    for instance in instances:
                        if (
                            client_info.node_ip == local_ip
                            and instance.user == client_info.user
                            and instance.image_id == client_info.image_id
                        ):
                            find_client_info = True
                            client_info.instance_state.state = instance.state
                            client_info.vm_info.vm_port = instance.n_port
                            client_info.vm_info.vm_password = instance.str_password
                            break
                    if not find_client_info and client_info.node_ip == local_ip:
                        client_info.instance_state.state = thd_TRANSACT_STATE.TERMINATED
            else:
                logger.error("p_get_client_data: real ldap ip error")
        else:
            logger.error("p_get_client_data: get local ip error")
    else:
        logger.info("real clc not online")
        local_ip = utility.get_local_publicip()
        if user == "super":
            logon_users = _get_logon_users()
            logger.info("logon user: %s" % str(logon_users))
            for usrName in logon_users:
                local_client = _read_client_infos(usrName)
                for lcClient in local_client:
                    if lcClient.vm_info.is_clear_power_off:
                        client_infos.append(lcClient)
        else:
            client_infos = _read_client_infos(user)
        logger.info("the saved client info number : %d " % len(client_infos))
        realUser = user
        if user == "super":
            realUser = "******"
        instances = OpenLdap.get_instance_states(local_ip, realUser)
        logger.info("the instance: %s" % str(instances))
        for client_info in client_infos:
            if user == "super":
                client_info.run_as_super = True
            else:
                client_info.run_as_super = False
            if not client_info.instance_state.is_local:  # remote instance can not be run
                client_info.instance_state.is_can_run = False
                client_info.instance_state.state = thd_TRANSACT_STATE.TERMINATED
            else:
                if _image_cache_exist(client_info.image_id, client_info.image_size):  # the image is cached
                    client_info.instance_state.is_can_run = True
                else:
                    client_info.instance_state.is_can_run = False
            find_client_info = False
            for instance in instances:
                if (
                    client_info.instance_state.is_local
                    and instance.user == client_info.user
                    and instance.image_id == client_info.image_id
                ):
                    find_client_info = True
                    client_info.instance_state.state = instance.state
                    client_info.vm_info.vm_port = instance.n_port
                    client_info.vm_info.vm_password = instance.str_password
                    break
            if not find_client_info:
                client_info.instance_state.state = thd_TRANSACT_STATE.TERMINATED
    logger.debug("p_get_client_data: %s" % str(client_infos))
    return client_infos