mgsingletask.cpp

来自「一款LINUX下的下载软件」· C++ 代码 · 共 878 行 · 第 1/2 页

    for ( it = m_sMirrorUrl.begin();it != m_sMirrorUrl.end();it++ )
    {
        m_pFM->AddMirrorUrl( *it );
    }

    //start work thread
    pthread_setcancelstate ( PTHREAD_CANCEL_DISABLE, &oldstate );
	pthread_mutex_lock( &m_AntsMutex );

    for ( int i = 0;i < m_nAnts;i++ )
    {
        //not run when construct 2006/09/03
        m_pAnts[ i ] = new CProAnts(
                           this,   //用于线程消息回送
                           m_pFM,
                           i + 1,  //线程自然数编号，回送消息时带上，用于分辨消息来源
                           m_nFileLen,
                           m_nRetry,
                           m_nRetryWait
                       );


        //if need proxy, make here

        if ( m_bUseProxy )
        {
            m_pAnts[ i ] ->SetProxy( m_Proxy, m_ProxyPort, m_ProxyUser, m_ProxyPass, m_ProxyVersion );
        }

        if ( m_bUseFtpProxy )
        {
            m_pAnts[ i ] ->SetFtpProxy( m_FtpProxy, m_FtpProxyPort );
        }

        if ( m_bUseHttpProxy )
        {

            m_pAnts[ i ] ->SetHttpProxy( m_HttpProxy, m_HttpProxyPort );
        }

        m_pAnts[ i ] ->Go();

    }


    m_nRunningAnts = m_nAnts;
	m_bInitAnts = true;
	pthread_mutex_unlock( &m_AntsMutex );
    pthread_setcancelstate ( oldstate, NULL );

    pthread_exit( 0 );

}

//goto work thread
bool CMgSingleTask::Go()
{
    pthread_create( &m_nInitThread, NULL, SwapInitThread, this );
#ifdef WIN32
    return ( m_nInitThread.p != NULL );
#else
    return ( m_nInitThread != 0 );
#endif
}

void CMgSingleTask::UpdateRunningTable( CShowTableWindow* pwin )
{
    //设置显示范围
    m_pShowTableWin = pwin;

    //如果此时还没有获得文件长度呢？
    //m_pShowTableWin->SetRange( m_nFileLen );

    if ( m_pFM )
    {
        m_pFM->UpdateRunningTable( m_pShowTableWin );
    }

    m_bUI = true;
    m_nUItype = 1;
}


void CMgSingleTask::CloseUpdateUI()
{
    if ( m_bUI && m_nUItype == 1 && m_pFM != NULL )
    {
        m_pFM->CloseUpdateUI();
    }

    m_bUI = false;
}


//tid从1开始计算
//tid可以是负数，－1代表信息提取，－2代表文件管理
void CMgSingleTask::UpdateThreadInfo( CThreadInfoWindow* pwin, int tid )
{
    m_pThreadInfoWin = pwin;
    m_bUI = true;
    m_nUItype = 2; //线程信息，非图表信息
    m_nMsgOutThreadId = tid;

    pwin->DeleteAllItems(); //清空

    if ( tid > 0 && tid <= 10 )
    {
        //dump all msg first time

        for ( int i = 0;i < int( m_sThreadInfo[ tid - 1 ].size() );i++ )
        {
            pwin->AddInfo( m_sThreadInfo[ tid - 1 ][ i ].type,
                           m_sThreadInfo[ tid - 1 ][ i ].info, m_sThreadInfo[ tid - 1 ][ i ].time );
        }
    }
    else if ( tid == -1 )
    {
        //dump all msg first time

        for ( int i = 0;i < int( m_sInfoThread.size() );i++ )
        {
            pwin->AddInfo( m_sInfoThread[ i ].type, m_sInfoThread[ i ].info , m_sInfoThread[ i ].time );
        }
    }
    else if ( tid == -2 )
    {
        //dump all msg first time

        for ( int i = 0;i < int( m_sFileManager.size() );i++ )
        {
            pwin->AddInfo( m_sFileManager[ i ].type, m_sFileManager[ i ].info, m_sFileManager[ i ].time );
        }
    }
    else
    {
        //invalid threadid
        //DBGOUT( "invalid tid" );
		return;
    }
}

//tid是线程编号，从1开始计算，负数代表另外两个
//output message,tid is 1 based
void CMgSingleTask::OutMsg( int tid, string str, _MSGTYPE type )
{


    _task_info x;
    x.time = time( NULL );
    x.type = type;
    x.info = str;


    if ( tid > 0 && tid < 11 )
    {
        m_sThreadInfo[ tid - 1 ].push_back( x );
    }
    else if ( tid == -1 )
    {
        m_sInfoThread.push_back( x );
    }
    else if ( tid == -2 )
    {
        m_sFileManager.push_back( x );
    }
    else
    {
		return;
    }

    //输出到界面
    if ( m_bUI && m_nUItype == 2 && m_pThreadInfoWin != NULL && m_nMsgOutThreadId == tid )
    {
        m_pThreadInfoWin->AddInfo( type, str, x.time );
    }

}

void CMgSingleTask::GetRunningArgs( float& fratio, llong& finish, int& speed, int& ttf )
{
    if ( m_pFM != NULL )
    {
        m_pFM->GetRunningArgs( fratio, finish, speed, ttf );
    }
    else
    {
        fratio = 0.0f;
        finish = 0;
        speed = 0;
        ttf = -1;
    }
}


bool CMgSingleTask::ThreadDown()
{
    if ( m_nAnts <= 1 )
        return false;

    if ( m_nRunningAnts <= 1 )
        return false;


    pthread_mutex_lock( &m_AntsMutex );

	if( !m_bInitAnts ) {
		if( m_nAnts <=1 ) {
			pthread_mutex_unlock( &m_AntsMutex );
			return false;			
		}else{
			m_nAnts--;
			pthread_mutex_unlock( &m_AntsMutex );
			return true;
		}
	}
    //要把最后的线程拿掉，如果最后的线程已经退出了，这次就只拿掉这个退出的线程

    if ( m_pAnts[ m_nAnts - 1 ] != NULL )
    {
        delete m_pAnts[ m_nAnts - 1 ];
        m_pAnts[ m_nAnts - 1 ] = NULL;
        m_sThreadInfo[ m_nAnts - 1 ].clear();  //index??
        m_pFM->ThreadQuit( m_nAnts );		//index ??
        m_nRunningAnts--;
        m_nAnts--;
    }
    else
    {
        m_nAnts--;
        m_sThreadInfo[ m_nAnts ].clear();
    }


    pthread_mutex_unlock( &m_AntsMutex );
    return true;
}


bool CMgSingleTask::ThreadUp()
{
    if ( m_nAnts >= 10 )
        return false;

    if ( m_nRunningAnts >= 10 )
        return false;

    pthread_mutex_lock( &m_AntsMutex );

	if( !m_bInitAnts ) {
		if( m_nAnts >=10 ) {
			pthread_mutex_unlock( &m_AntsMutex );
			return false;			
		}else{
			m_nAnts++;
			pthread_mutex_unlock( &m_AntsMutex );
			return true;
		}
	}

    if ( m_pAnts[ m_nAnts ] == NULL )
    {
        m_pAnts[ m_nAnts ] = new CProAnts(
                                 this,   //用于线程消息回送
                                 m_pFM,
                                 m_nAnts + 1,    //线程自然数编号，回送消息时带上，用于分辨消息来源
                                 m_nFileLen,
                                 m_nRetry,
                                 m_nRetryWait
                             );

        if ( m_bUseProxy )
        {
            m_pAnts[ m_nAnts ] ->SetProxy(
                m_Proxy, m_ProxyPort, m_ProxyUser, m_ProxyPass, m_ProxyVersion );
        }

        if ( m_bUseFtpProxy )
        {
            m_pAnts[ m_nAnts ] ->SetFtpProxy( m_FtpProxy, m_FtpProxyPort );
        }

        if ( m_bUseHttpProxy )
        {
            m_pAnts[ m_nAnts ] ->SetHttpProxy( m_HttpProxy, m_HttpProxyPort );
        }

        if( !m_pAnts[ m_nAnts ] ->Go() )
		{
			//sleep(50);
			m_pAnts[ m_nAnts ] ->Go();
		}

        m_nRunningAnts++;
        m_nAnts++;
    }
    else
    {
        pthread_mutex_unlock( &m_AntsMutex );
        return false;
    }


    pthread_mutex_unlock( &m_AntsMutex );
    return true;
}

void CMgSingleTask::SetProxy(
    std::string server,
    int port,
    std::string user,
    std::string pass,
    _SOCKVER ver )
{


    m_bUseProxy = true;
    m_Proxy = server;
    m_ProxyPort = port;
    m_ProxyUser = user;
    m_ProxyPass = pass;
    m_ProxyVersion = ver;

}

void CMgSingleTask::SetHttpProxy( std::string server, int port )
{

    m_bUseHttpProxy = true;
    m_HttpProxy = server;
    m_HttpProxyPort = port;
}

void CMgSingleTask::SetFtpProxy( std::string server, int port )
{

    m_bUseFtpProxy = true;
    m_FtpProxy = server;
    m_FtpProxyPort = port;
}

void CMgSingleTask::HeartBeat()
{
    if ( m_pFM != NULL )
        m_pFM->HeartBeat();
}

CTaskManager* CMgSingleTask::GetParent()
{
    return m_pParent;
}

CThreadInfoWindow* CMgSingleTask::GetThreadInfoWin()
{
    return m_pThreadInfoWin;
}

CShowTableWindow* CMgSingleTask::GetShowTableWin()
{
    return m_pShowTableWin;
}

int CMgSingleTask::UpdateUItype()
{
    return m_nUItype;
}

bool CMgSingleTask::UpdateUI()
{
    return m_bUI;
}

std::string CMgSingleTask::GetTaskUrl()
{
    return m_sUrl;
}

std::string CMgSingleTask::GetFilename()
{
    return m_sFilename;
}

int CMgSingleTask::GetErrorTime()
{
    return m_nError;
}

llong CMgSingleTask::GetFileLen()
{
    return m_nFileLen;
}

int CMgSingleTask::GetTaskID()
{
    return m_nTaskID;
}

_SINGLE_TASK_STATUS CMgSingleTask::GetStatus()
{
    return m_nStatus;
}

int	CMgSingleTask::GetRunningThreadNum()
{
    return m_nRunningAnts;
}

int CMgSingleTask::GetThreadNum()
{
    return m_nAnts;
};

//记录错误事件
void CMgSingleTask::LogError()
{
    //记录全部
    std::vector<_task_info>::const_iterator it;

    for ( it = m_sInfoThread.begin();it != m_sInfoThread.end();it++ )
    {
        gfTaskLog( m_nTaskID, it->info, it->type, it->time );
    }

    for ( it = m_sFileManager.begin();it != m_sFileManager.end();it++ )
    {
        gfTaskLog( m_nTaskID, it->info, it->type, it->time );
    }

}

//before call go(),you can add mirror url
void CMgSingleTask::AddMirrorUrl( std::string url )
{
    m_sMirrorUrl.push_back( url );

    if ( m_pFM != NULL )
        m_pFM->AddMirrorUrl( url );
}