Ticket #139: trac139_6_8.patch

File trac139_6_8.patch, 48.1 kB (added by Thyme Lawn, 3 months ago)

Patch for boinc_core_release_6_8 (revision 18844)

  • client/boinc_cmd.cpp

    old new  
    7272 --result url result_name op        job operation\n\ 
    7373   op = suspend | resume | abort | graphics_window | graphics_fullscreen\n\ 
    7474 --project URL op                   project operation\n\ 
    75    op = reset | detach | update | suspend | resume | nomorework | allowmorework\n\ 
     75   op = reset | detach | update | suspend | resume | network_suspend | network_resume | nomorework | allowmorework\n\ 
    7676 --file_transfer URL filename op    file transfer operation\n\ 
    7777   op = retry | abort\n\ 
    7878 --set_run_mode mode duration       set run mode for given duration\n\ 
     
    268268            retval = rpc.project_op(project, "suspend"); 
    269269        } else if (!strcmp(op, "resume")) { 
    270270            retval = rpc.project_op(project, "resume"); 
     271        } else if (!strcmp(op, "network_suspend")) { 
     272            retval = rpc.project_op(project, "network_suspend"); 
     273        } else if (!strcmp(op, "network_resume")) { 
     274            retval = rpc.project_op(project, "network_resume"); 
    271275        } else if (!strcmp(op, "detach")) { 
    272276            retval = rpc.project_op(project, "detach"); 
    273277        } else if (!strcmp(op, "update")) { 
    274278            retval = rpc.project_op(project, "update"); 
    275         } else if (!strcmp(op, "suspend")) { 
    276             retval = rpc.project_op(project, "suspend"); 
    277         } else if (!strcmp(op, "resume")) { 
    278             retval = rpc.project_op(project, "resume"); 
    279279        } else if (!strcmp(op, "nomorework")) { 
    280280            retval = rpc.project_op(project, "nomorework"); 
    281281        } else if (!strcmp(op, "allowmorework")) { 
  • client/client_types.cpp

    old new  
    102102    send_time_stats_log = 0; 
    103103    send_job_log = 0; 
    104104    suspended_via_gui = false; 
     105    network_suspended_via_gui = false; 
    105106    dont_request_more_work = false; 
    106107    detach_when_done = false; 
    107108    attached_via_acct_mgr = false; 
     
    181182        if (parse_bool(buf, "non_cpu_intensive", non_cpu_intensive)) continue; 
    182183        if (parse_bool(buf, "verify_files_on_app_start", verify_files_on_app_start)) continue; 
    183184        if (parse_bool(buf, "suspended_via_gui", suspended_via_gui)) continue; 
     185        if (parse_bool(buf, "network_suspended_via_gui", network_suspended_via_gui)) continue; 
    184186        if (parse_bool(buf, "dont_request_more_work", dont_request_more_work)) continue; 
    185187        if (parse_bool(buf, "detach_when_done", detach_when_done)) continue; 
    186188        if (parse_bool(buf, "ended", ended)) continue; 
     
    253255                "    <sched_rpc_pending>%d</sched_rpc_pending>\n" 
    254256                "    <send_time_stats_log>%d</send_time_stats_log>\n" 
    255257                "    <send_job_log>%d</send_job_log>\n" 
    256         "%s%s%s%s%s%s%s%s%s%s%s%s", 
     258        "%s%s%s%s%s%s%s%s%s%s%s%s%s", 
    257259        master_url, 
    258260        project_name, 
    259261        symstore, 
     
    289291        non_cpu_intensive?"    <non_cpu_intensive/>\n":"", 
    290292        verify_files_on_app_start?"    <verify_files_on_app_start/>\n":"", 
    291293        suspended_via_gui?"    <suspended_via_gui/>\n":"", 
     294        network_suspended_via_gui?"    <network_suspended_via_gui/>\n":"", 
    292295        dont_request_more_work?"    <dont_request_more_work/>\n":"", 
    293296        detach_when_done?"    <detach_when_done/>\n":"", 
    294297        ended?"    <ended/>\n":"", 
     
    365368    non_cpu_intensive = p.non_cpu_intensive; 
    366369    verify_files_on_app_start = p.verify_files_on_app_start; 
    367370    suspended_via_gui = p.suspended_via_gui; 
     371    network_suspended_via_gui = p.network_suspended_via_gui; 
    368372    dont_request_more_work = p.dont_request_more_work; 
    369373    detach_when_done = p.detach_when_done; 
    370374    attached_via_acct_mgr = p.attached_via_acct_mgr; 
  • client/client_types.h

    old new  
    266266    int send_job_log; 
    267267 
    268268    bool suspended_via_gui; 
     269    bool network_suspended_via_gui; 
    269270        /// Return work, but don't request more 
    270271        /// Used for a clean exit to a project, 
    271272        /// or if a user wants to pause doing work for the project 
  • client/cs_files.cpp

    old new  
    262262            fip->pers_file_xfer = pfx; 
    263263            pers_file_xfers->insert(fip->pers_file_xfer); 
    264264            action = true; 
    265         } else if (fip->upload_when_present && fip->status == FILE_PRESENT && !fip->uploaded) { 
     265        } else if (!fip->project->network_suspended_via_gui && 
     266                   fip->upload_when_present && 
     267                   fip->status == FILE_PRESENT && 
     268                   !fip->uploaded) { 
    266269            pfx = new PERS_FILE_XFER; 
    267270            pfx->init(fip, true); 
    268271            fip->pers_file_xfer = pfx; 
     
    279282    iter = pers_file_xfers->pers_file_xfers.begin(); 
    280283    while (iter != pers_file_xfers->pers_file_xfers.end()) { 
    281284        pfx = *iter; 
     285        fip = pfx->fip; 
    282286 
    283287        // If the transfer finished, remove the PERS_FILE_XFER object 
    284288        // from the set and delete it 
    285289        // 
    286290        if (pfx->pers_xfer_done) { 
    287             fip = pfx->fip; 
    288291            if (fip->generated_locally || fip->upload_when_present) { 
    289292                // file has been uploaded - delete if not sticky 
    290293                // 
     
    331334            action = true; 
    332335            // `delete pfx' should have set pfx->fip->pfx to NULL 
    333336            assert (fip == NULL || fip->pers_file_xfer == NULL); 
     337        } else if ((!pfx->fxp || pfx->fxp->http_op_done()) && 
     338                   pfx->is_upload && 
     339                   fip->project->network_suspended_via_gui) { 
     340            // Reset persistent file upload if networking 
     341            // has been disabled for the project 
     342            msg_printf(fip->project, MSG_INFO, 
     343                "Project networking suspended, suspend upload and reset timer for %s", fip->name 
     344            ); 
     345            iter = pers_file_xfers->pers_file_xfers.erase(iter); 
     346            delete pfx; 
     347            action = true; 
     348            // `delete pfx' should have set pfx->fip->pfx to NULL 
     349            assert (fip == NULL || fip->pers_file_xfer == NULL); 
    334350        } else { 
    335351            iter++; 
    336352        } 
  • client/cs_scheduler.cpp

    old new  
    10061006        p = projects[i]; 
    10071007        if (p->waiting_until_min_rpc_time()) continue; 
    10081008        if (p->suspended_via_gui) continue; 
     1009        if (p->network_suspended_via_gui) continue; 
    10091010        if (p->master_url_fetch_pending) { 
    10101011            return p; 
    10111012        } 
     
    10581059        if (honor_suspend && p->suspended_via_gui) { 
    10591060            continue; 
    10601061        } 
     1062        if (honor_suspend && p->network_suspended_via_gui) { 
     1063            continue; 
     1064        } 
    10611065        if (p->sched_rpc_pending) { 
    10621066            return p; 
    10631067        } 
     
    10731077        p = projects[i]; 
    10741078        if (p->waiting_until_min_rpc_time()) continue; 
    10751079        if (p->suspended_via_gui) continue; 
     1080        if (p->network_suspended_via_gui) continue; 
    10761081        if (p->trickle_up_pending) { 
    10771082            return p; 
    10781083        } 
     
    10991104        PROJECT* p = r->project; 
    11001105        if (p->waiting_until_min_rpc_time()) continue; 
    11011106        if (p->suspended_via_gui) continue; 
     1107        if (p->network_suspended_via_gui) continue; 
    11021108 
    11031109        if (config.report_results_immediately) { 
    11041110            return p; 
  • client/gui_rpc_server_ops.cpp

    old new  
    258258        p->suspended_via_gui = false; 
    259259        gstate.request_schedule_cpus("project resumed by user"); 
    260260        gstate.request_work_fetch("project resumed by user"); 
     261    } else if (!strcmp(op, "network_suspend")) { 
     262        msg_printf(p, MSG_INFO, "network activity suspended by user"); 
     263        p->network_suspended_via_gui = true; 
     264    } else if (!strcmp(op, "network_resume")) { 
     265        msg_printf(p, MSG_INFO, "network activity resumed by user"); 
     266        p->network_suspended_via_gui = false; 
    261267    } else if (!strcmp(op, "detach")) { 
    262268        if (p->attached_via_acct_mgr) { 
    263269            msg_printf(p, MSG_USER_ERROR, 
     
    11731179        handle_project_op(request_msg, mf, "suspend"); 
    11741180    } else if (match_tag(request_msg, "<project_resume")) { 
    11751181        handle_project_op(request_msg, mf, "resume"); 
     1182    } else if (match_tag(request_msg, "<project_network_suspend")) { 
     1183        handle_project_op(request_msg, mf, "network_suspend"); 
     1184    } else if (match_tag(request_msg, "<project_network_resume")) { 
     1185        handle_project_op(request_msg, mf, "network_resume"); 
    11761186    } else if (match_tag(request_msg, "<set_run_mode")) { 
    11771187        handle_set_run_mode(request_msg, mf); 
    11781188    } else if (match_tag(request_msg, "<quit")) { 
  • client/scheduler_op.cpp

    old new  
    210210int SCHEDULER_OP::start_rpc(PROJECT* p) { 
    211211    int retval; 
    212212    char request_file[1024], reply_file[1024], buf[256]; 
     213    char *trickle_up_msg; 
    213214 
    214215    safe_strcpy(scheduler_url, p->get_scheduler_url(url_index, url_random)); 
    215216    if (log_flags.sched_ops) { 
    216217        msg_printf(p, MSG_INFO, 
    217218            "Sending scheduler request: %s.", rpc_reason_string(reason) 
    218219        ); 
     220        if (p->trickle_up_pending && reason != RPC_REASON_TRICKLE_UP) { 
     221            trickle_up_msg = ", sending trickle-up message"; 
     222        } else { 
     223            trickle_up_msg = ""; 
     224        } 
    219225        if (cpu_work_fetch.req_secs || cuda_work_fetch.req_secs) { 
    220226            if (coproc_cuda) { 
    221227                if (cpu_work_fetch.req_secs && cuda_work_fetch.req_secs) { 
     
    230236            } 
    231237            if (p->nresults_returned) { 
    232238                msg_printf(p, MSG_INFO, 
    233                     "Reporting %d completed tasks, requesting new tasks%s", 
    234                     p->nresults_returned, buf 
     239                    "Reporting %d completed tasks, requesting new tasks%s%s", 
     240                    p->nresults_returned, buf, trickle_up_msg 
    235241                ); 
    236242            } else { 
    237                 msg_printf(p, MSG_INFO, "Requesting new tasks%s", buf); 
     243                msg_printf(p, MSG_INFO, "Requesting new tasks%s%s", buf, trickle_up_msg); 
    238244            } 
    239245        } else { 
    240246            if (p->nresults_returned) { 
    241247                msg_printf(p, MSG_INFO, 
    242                     "Reporting %d completed tasks, not requesting new tasks", 
    243                     p->nresults_returned 
     248                    "Reporting %d completed tasks, not requesting new tasks%s", 
     249                    p->nresults_returned, trickle_up_msg 
    244250                ); 
    245251            } else { 
    246                 msg_printf(p, MSG_INFO, "Not reporting or requesting tasks"); 
     252                msg_printf(p, MSG_INFO, "Not reporting or requesting tasks%s", trickle_up_msg); 
    247253            } 
    248254        } 
    249255    } 
  • client/sim.h

    old new  
    194194    bool possibly_schedule_cpus(); 
    195195    void schedule_cpus(); 
    196196    bool enforce_schedule(); 
     197    void append_unfinished_time_slice(vector<RESULT*>&); 
    197198    bool no_work_for_a_cpu(); 
    198199    void append_unfinished_time_slice(vector<RESULT*> &runnable_jobs); 
    199200    void print_deadline_misses(); 
  • client/sim_util.cpp

    old new  
    138138    short_term_debt = 0; 
    139139    send_file_list = false; 
    140140    suspended_via_gui = false; 
     141    network_suspended_via_gui = false; 
    141142    dont_request_more_work = false; 
    142143    detach_when_done = false; 
    143144    attached_via_acct_mgr = false; 
  • client/work_fetch.cpp

    old new  
    105105bool PROJECT_WORK_FETCH::compute_can_fetch_work(PROJECT* p) { 
    106106    if (p->non_cpu_intensive) return false; 
    107107    if (p->suspended_via_gui) return false; 
     108    if (p->network_suspended_via_gui && p->sched_rpc_pending != RPC_REASON_USER_REQ) return false; 
    108109    if (p->master_url_fetch_pending) return false; 
    109110    if (p->min_rpc_time > gstate.now) return false; 
    110111    if (p->dont_request_more_work) return false; 
     
    311312        RSC_PROJECT_WORK_FETCH& pwf = project_state(p); 
    312313        double bt = pwf.backoff_time>gstate.now?pwf.backoff_time-gstate.now:0; 
    313314        msg_printf(p, MSG_INFO, 
    314             "[wfd] %s: fetch share %.2f debt %.2f backoff dt %.2f int %.2f%s%s%s%s%s", 
     315            "[wfd] %s: fetch share %.2f debt %.2f backoff dt %.2f int %.2f%s%s%s%s%s%s", 
    315316            name, 
    316317            pwf.fetchable_share, pwf.debt, bt, pwf.backoff_interval, 
    317318            p->suspended_via_gui?" (susp via GUI)":"", 
     319            p->network_suspended_via_gui?" (net susp via GUI)":"", 
    318320            p->master_url_fetch_pending?" (master fetch pending)":"", 
    319321            p->min_rpc_time > gstate.now?" (comm deferred)":"", 
    320322            p->dont_request_more_work?" (no new tasks)":"", 
     
    815817 
    816818bool PROJECT::can_request_work() { 
    817819    if (suspended_via_gui) return false; 
     820    if (network_suspended_via_gui && sched_rpc_pending != RPC_REASON_USER_REQ) return false; 
    818821    if (master_url_fetch_pending) return false; 
    819822    if (min_rpc_time > gstate.now) return false; 
    820823    if (dont_request_more_work) return false; 
  • clientgui/DlgItemProperties.cpp

    old new  
    114114    addProperty(_("Computer ID"), wxString::Format(wxT("%d"), project->hostid)); 
    115115        addProperty(_("Non CPU intensive"),project->non_cpu_intensive ? _("yes") : _("no")); 
    116116        addProperty(_("Suspended via GUI"),project->suspended_via_gui ? _("yes") : _("no")); 
     117        addProperty(_("Network activity suspended via GUI"),project->network_suspended_via_gui ? _("yes") : _("no")); 
    117118        addProperty(_("Don't request more work"),project->dont_request_more_work ? _("yes") : _("no")); 
    118119        addProperty(_("Scheduler call in progress"),project->scheduler_rpc_in_progress ? _("yes") : _("no")); 
     120        addProperty(_("Trickle-up pending"),project->trickle_up_pending ? _("yes") : _("no")); 
    119121        addProperty(_("Attached via account manager"),project->attached_via_acct_mgr ? _("yes") : _("no")); 
    120122        addProperty(_("Detach when done"),project->detach_when_done ? _("yes") : _("no")); 
    121123        addProperty(_("Ended"),project->ended ? _("yes") : _("no")); 
  • clientgui/Events.h

    old new  
    9191#define ID_TASK_PROJECT_RESET                   9006 
    9292#define ID_TASK_PROJECT_DETACH                  9007 
    9393#define ID_TASK_PROJECT_SHOW_PROPERTIES         9008 
     94#define ID_TASK_PROJECT_SUSPEND_NETWORK         9009 
     95#define ID_TASK_PROJECT_RESUME_NETWORK          9010 
    9496#define ID_TASK_PROJECT_WEB_PROJDEF_MIN         9100 
    9597#define ID_TASK_PROJECT_WEB_PROJDEF_MAX         9150 
    9698#define ID_TASK_WORK_SUSPEND                    9200 
  • clientgui/MainDocument.cpp

    old new  
    13111311    return iRetVal; 
    13121312} 
    13131313 
     1314int CMainDocument::ProjectSuspendNetwork(int iIndex) { 
     1315    PROJECT* pProject = NULL; 
     1316    int iRetVal = -1; 
     1317 
     1318    pProject = project(iIndex); 
     1319 
     1320    if (pProject) 
     1321        iRetVal = rpc.project_op((*pProject), "network_suspend"); 
     1322 
     1323    return iRetVal; 
     1324} 
     1325 
     1326int CMainDocument::ProjectSuspendNetwork(const wxString& projectname) { 
     1327    PROJECT* pProject = NULL; 
     1328    int iRetVal = -1; 
     1329 
     1330    pProject = project(projectname); 
     1331 
     1332    if (pProject) 
     1333        iRetVal = rpc.project_op((*pProject), "network_suspend"); 
     1334 
     1335    return iRetVal; 
     1336} 
     1337 
     1338int CMainDocument::ProjectResumeNetwork(int iIndex) { 
     1339    PROJECT* pProject = NULL; 
     1340    int iRetVal = -1; 
     1341 
     1342    pProject = project(iIndex); 
     1343 
     1344    if (pProject) 
     1345        iRetVal = rpc.project_op((*pProject), "network_resume"); 
     1346 
     1347    return iRetVal; 
     1348} 
     1349 
     1350int CMainDocument::ProjectResumeNetwork(const wxString& projectname) { 
     1351    PROJECT* pProject = NULL; 
     1352    int iRetVal = -1; 
     1353 
     1354    pProject = project(projectname); 
     1355 
     1356    if (pProject) 
     1357        iRetVal = rpc.project_op((*pProject), "network_resume"); 
     1358 
     1359    return iRetVal; 
     1360} 
     1361 
    13141362int CMainDocument::ProjectNoMoreWork(int iIndex) { 
    13151363    PROJECT* pProject = NULL; 
    13161364    int iRetVal = -1; 
  • clientgui/MainDocument.h

    old new  
    229229        int                         ProjectSuspend(const wxString& projectname); 
    230230    int                         ProjectResume(int iIndex); 
    231231        int                         ProjectResume(const wxString& projectname); 
     232    int                         ProjectSuspendNetwork(int iIndex); 
     233        int                         ProjectSuspendNetwork(const wxString& projectname); 
     234    int                         ProjectResumeNetwork(int iIndex); 
     235        int                         ProjectResumeNetwork(const wxString& projectname); 
    232236 
    233237 
    234238    // 
  • clientgui/ViewProjects.cpp

    old new  
    4848#define GRP_WEBSITES 1 
    4949 
    5050// buttons in the "tasks" area 
    51 #define BTN_UPDATE       0 
    52 #define BTN_SUSPEND      1 
    53 #define BTN_NOWORK       2 
    54 #define BTN_RESET        3 
    55 #define BTN_DETACH       4 
    56 #define BTN_PROPERTIES   5 
     51#define BTN_UPDATE            0 
     52#define BTN_SUSPEND           1 
     53#define BTN_SUSPEND_NETWORK   2 
     54#define BTN_NOWORK            3 
     55#define BTN_RESET             4 
     56#define BTN_DETACH            5 
     57#define BTN_PROPERTIES        6 
    5758 
    5859 
    5960CProject::CProject() { 
     
    7778BEGIN_EVENT_TABLE (CViewProjects, CBOINCBaseView) 
    7879    EVT_BUTTON(ID_TASK_PROJECT_UPDATE, CViewProjects::OnProjectUpdate) 
    7980    EVT_BUTTON(ID_TASK_PROJECT_SUSPEND, CViewProjects::OnProjectSuspend) 
     81    EVT_BUTTON(ID_TASK_PROJECT_SUSPEND_NETWORK, CViewProjects::OnProjectSuspendNetwork) 
    8082    EVT_BUTTON(ID_TASK_PROJECT_NONEWWORK, CViewProjects::OnProjectNoNewWork) 
    8183    EVT_BUTTON(ID_TASK_PROJECT_RESET, CViewProjects::OnProjectReset) 
    8284    EVT_BUTTON(ID_TASK_PROJECT_DETACH, CViewProjects::OnProjectDetach) 
     
    183185    ); 
    184186    pGroup->m_Tasks.push_back( pItem ); 
    185187 
     188    pItem = new CTaskItem( 
     189        _("Suspend network"), 
     190        _("Suspend network activity for this project.  Stop uploads and reset their timers, block scheduler requests.  Downloads will be completed."), 
     191        ID_TASK_PROJECT_SUSPEND_NETWORK 
     192    ); 
     193    pGroup->m_Tasks.push_back( pItem ); 
     194 
    186195        pItem = new CTaskItem( 
    187196        _("No new tasks"), 
    188197        _("Don't get new tasks for this project."), 
     
    354363} 
    355364 
    356365 
     366void CViewProjects::OnProjectSuspendNetwork( wxCommandEvent& WXUNUSED(event) ) { 
     367    wxLogTrace(wxT("Function Start/End"), wxT("CViewProjects::OnProjectSuspendNetwork - Function Begin")); 
     368 
     369    CMainDocument*  pDoc   = wxGetApp().GetDocument(); 
     370    CAdvancedFrame* pFrame = wxDynamicCast(GetParent()->GetParent()->GetParent(), CAdvancedFrame); 
     371    int row; 
     372 
     373    wxASSERT(pDoc); 
     374    wxASSERT(wxDynamicCast(pDoc, CMainDocument)); 
     375    wxASSERT(pFrame); 
     376    wxASSERT(wxDynamicCast(pFrame, CAdvancedFrame)); 
     377    wxASSERT(m_pListPane); 
     378 
     379    row = -1; 
     380    while (1) { 
     381        // Step through all selected items 
     382        row = m_pListPane->GetNextItem(row, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED); 
     383        if (row < 0) break; 
     384         
     385        PROJECT* project = pDoc->project(m_iSortedIndexes[row]); 
     386        if (project) { 
     387            if (project->network_suspended_via_gui) { 
     388                pFrame->UpdateStatusText(_("Resuming project network activity...")); 
     389                pDoc->ProjectResumeNetwork(m_iSortedIndexes[row]); 
     390                pFrame->UpdateStatusText(wxT("")); 
     391            } else { 
     392                pFrame->UpdateStatusText(_("Suspending project network activity...")); 
     393                pDoc->ProjectSuspendNetwork(m_iSortedIndexes[row]); 
     394                pFrame->UpdateStatusText(wxT("")); 
     395            } 
     396        } 
     397    } 
     398     
     399    m_bForceUpdateSelection = true; 
     400    UpdateSelection(); 
     401    pFrame->FireRefreshView(); 
     402 
     403    wxLogTrace(wxT("Function Start/End"), wxT("CViewProjects::OnProjectSuspendNetwork - Function End")); 
     404} 
     405 
     406 
    357407void CViewProjects::OnProjectNoNewWork( wxCommandEvent& WXUNUSED(event) ) { 
    358408    wxLogTrace(wxT("Function Start/End"), wxT("CViewProjects::OnProjectNoNewWork - Function Begin")); 
    359409 
     
    652702    PROJECT*            project = NULL; 
    653703    CMainDocument*      pDoc = wxGetApp().GetDocument(); 
    654704    int                 i, n, row; 
    655     bool                wasSuspended=false, wasNoNewWork=false; 
     705    bool                wasSuspended=false, wasNetworkSuspended=false, wasNoNewWork=false; 
    656706    bool                enableUpdate = false; 
    657707    bool                enableSuspendResume = false; 
     708    bool                enableNetworkSuspendResume = false; 
    658709    bool                enableNoNewTasks = false; 
    659710    bool                enableReset = false; 
    660711    bool                enableDetach = false; 
     
    675726    if (n > 0) { 
    676727        enableUpdate = true; 
    677728        enableSuspendResume = true; 
     729        enableNetworkSuspendResume = true; 
    678730        enableNoNewTasks = true; 
    679731        enableReset = true; 
    680732        enableDetach = true; 
     
    715767        } 
    716768 
    717769        if (i == 0) { 
     770            wasNetworkSuspended = project->network_suspended_via_gui; 
     771             if (project->network_suspended_via_gui) { 
     772                m_pTaskPane->UpdateTask( 
     773                    pGroup->m_Tasks[BTN_SUSPEND_NETWORK], _("Resume network"), _("Resume network activity for this project.") 
     774                ); 
     775            } else { 
     776                m_pTaskPane->UpdateTask( 
     777                    pGroup->m_Tasks[BTN_SUSPEND_NETWORK], 
     778                    _("Suspend network"), 
     779                    _("Suspend network activity for this project.  Stop uploads and reset their timers, block scheduler requests.  Downloads will be completed.") 
     780                ); 
     781            } 
     782        } else { 
     783            if (wasNetworkSuspended != project->network_suspended_via_gui) { 
     784                // Disable Suspend / Resume button if the multiple selection 
     785                // has a mix of suspended and not suspended projects 
     786                enableNetworkSuspendResume = false; 
     787            } 
     788        } 
     789 
     790        if (i == 0) { 
    718791            wasNoNewWork = project->dont_request_more_work; 
    719792            if (project->dont_request_more_work) { 
    720793                m_pTaskPane->UpdateTask( 
     
    755828    // To minimize flicker, set each button only once to the final desired state 
    756829    pGroup->m_Tasks[BTN_UPDATE]->m_pButton->Enable(enableUpdate); 
    757830    pGroup->m_Tasks[BTN_SUSPEND]->m_pButton->Enable(enableSuspendResume); 
     831    pGroup->m_Tasks[BTN_SUSPEND_NETWORK]->m_pButton->Enable(enableNetworkSuspendResume); 
    758832    pGroup->m_Tasks[BTN_NOWORK]->m_pButton->Enable(enableNoNewTasks); 
    759833    pGroup->m_Tasks[BTN_RESET]->m_pButton->Enable(enableReset); 
    760834    pGroup->m_Tasks[BTN_DETACH]->m_pButton->Enable(enableDetach); 
     
    10501124        if (project->suspended_via_gui) { 
    10511125            append_to_status(strBuffer, _("Suspended by user")); 
    10521126        } 
     1127        else if (project->network_suspended_via_gui && project->sched_rpc_pending != RPC_REASON_USER_REQ) { 
     1128            append_to_status(strBuffer, _("Network activity suspended by user")); 
     1129        } 
    10531130        if (project->dont_request_more_work) { 
    10541131            append_to_status(strBuffer, _("Won't get new tasks")); 
    10551132        } 
     
    10611138        } 
    10621139        if (project->sched_rpc_pending) { 
    10631140            append_to_status(strBuffer, _("Scheduler request pending")); 
    1064                        append_to_status(strBuffer, wxString(rpc_reason_string(project->sched_rpc_pending), wxConvUTF8)); 
     1141            append_to_status(strBuffer, wxString(rpc_reason_string(project->sched_rpc_pending), wxConvUTF8)); 
    10651142        } 
     1143        if (project->trickle_up_pending && 
     1144            !project->scheduler_rpc_in_progress && 
     1145            project->sched_rpc_pending != RPC_REASON_TRICKLE_UP) { 
     1146            append_to_status(strBuffer, _("Trickle upload pending")); 
     1147        } 
    10661148        if (project->scheduler_rpc_in_progress) { 
    10671149            append_to_status(strBuffer, _("Scheduler request in progress")); 
    10681150        } 
  • clientgui/ViewProjects.h

    old new  
    6565 
    6666    void                    OnProjectUpdate( wxCommandEvent& event ); 
    6767    void                    OnProjectSuspend( wxCommandEvent& event ); 
     68    void                    OnProjectSuspendNetwork( wxCommandEvent& event ); 
    6869    void                    OnProjectNoNewWork( wxCommandEvent& event ); 
    6970    void                    OnProjectReset( wxCommandEvent& event ); 
    7071    void                    OnProjectDetach( wxCommandEvent& event ); 
  • clientgui/ViewProjectsBase.cpp

    old new  
    4747#define GRP_WEBSITES 1 
    4848 
    4949// buttons in the "tasks" area 
    50 #define BTN_UPDATE       0 
    51 #define BTN_SUSPEND      1 
    52 #define BTN_NOWORK       2 
    53 #define BTN_RESET        3 
    54 #define BTN_DETACH       4 
     50#define BTN_UPDATE            0 
     51#define BTN_SUSPEND           1 
     52#define BTN_SUSPEND_NETWORK   2 
     53#define BTN_NOWORK            3 
     54#define BTN_RESET             4 
     55#define BTN_DETACH            5 
    5556 
    5657 
    5758CProject::CProject() { 
     
    7475BEGIN_EVENT_TABLE (CViewProjects, CBOINCBaseView) 
    7576    EVT_BUTTON(ID_TASK_PROJECT_UPDATE, CViewProjects::OnProjectUpdate) 
    7677    EVT_BUTTON(ID_TASK_PROJECT_SUSPEND, CViewProjects::OnProjectSuspend) 
     78    EVT_BUTTON(ID_TASK_PROJECT_SUSPEND_NETWORK, CViewProjects::OnProjectSuspendNetwork) 
    7779    EVT_BUTTON(ID_TASK_PROJECT_NONEWWORK, CViewProjects::OnProjectNoNewWork) 
    7880    EVT_BUTTON(ID_TASK_PROJECT_RESET, CViewProjects::OnProjectReset) 
    7981    EVT_BUTTON(ID_TASK_PROJECT_DETACH, CViewProjects::OnProjectDetach) 
     
    118120    ); 
    119121    pGroup->m_Tasks.push_back( pItem ); 
    120122 
     123    pItem = new CTaskItem( 
     124        _("Suspend network"), 
     125        _("Suspend network activity for this project.  Stop uploads and reset their timers, block scheduler requests.  Downloads will be completed."), 
     126        ID_TASK_PROJECT_SUSPEND_NETWORK  
     127    ); 
     128    pGroup->m_Tasks.push_back( pItem ); 
     129 
    121130        pItem = new CTaskItem( 
    122131        _("No new tasks"), 
    123132        _("Don't get new tasks for this project."), 
     
    238247} 
    239248 
    240249 
     250void CViewProjects::OnProjectSuspendNetwork( wxCommandEvent& WXUNUSED(event) ) { 
     251    wxLogTrace(wxT("Function Start/End"), wxT("CViewProjects::OnProjectSuspendNetwork - Function Begin")); 
     252 
     253    CMainDocument*  pDoc   = wxGetApp().GetDocument(); 
     254    CAdvancedFrame* pFrame = wxDynamicCast(GetParent()->GetParent()->GetParent(), CAdvancedFrame); 
     255 
     256    wxASSERT(pDoc); 
     257    wxASSERT(wxDynamicCast(pDoc, CMainDocument)); 
     258    wxASSERT(pFrame); 
     259    wxASSERT(wxDynamicCast(pFrame, CAdvancedFrame)); 
     260    wxASSERT(m_pListPane); 
     261 
     262    PROJECT* project = pDoc->project(m_pListPane->GetFirstSelected()); 
     263    if (project->network_suspended_via_gui) { 
     264        pFrame->UpdateStatusText(_("Resuming project network activity...")); 
     265        pDoc->ProjectResumeNetwork(m_pListPane->GetFirstSelected()); 
     266        pFrame->UpdateStatusText(wxT("")); 
     267    } else { 
     268        pFrame->UpdateStatusText(_("Suspending project network activity...")); 
     269        pDoc->ProjectSuspendNetwork(m_pListPane->GetFirstSelected()); 
     270        pFrame->UpdateStatusText(wxT("")); 
     271    } 
     272 
     273    m_bForceUpdateSelection = true; 
     274    UpdateSelection(); 
     275    pFrame->FireRefreshView(); 
     276 
     277    wxLogTrace(wxT("Function Start/End"), wxT("CViewProjects::OnProjectSuspendNetwork - Function End")); 
     278} 
     279 
     280 
    241281void CViewProjects::OnProjectNoNewWork( wxCommandEvent& WXUNUSED(event) ) { 
    242282    wxLogTrace(wxT("Function Start/End"), wxT("CViewProjects::OnProjectNoNewWork - Function Begin")); 
    243283 
     
    561601                ); 
    562602            } 
    563603        } 
     604        m_pTaskPane->EnableTask(pGroup->m_Tasks[BTN_SUSPEND_NETWORK]); 
     605        if (project) { 
     606            if (project->suspended_via_gui) { 
     607                m_pTaskPane->UpdateTask( 
     608                    pGroup->m_Tasks[BTN_SUSPEND_NETWORK], _("Resume network"), _("Resume network activity for this project.") 
     609                ); 
     610            } else { 
     611                m_pTaskPane->UpdateTask( 
     612                    pGroup->m_Tasks[BTN_SUSPEND_NETWORK], 
     613                    _("Suspend network"), 
     614                    _("Suspend network activity for this project.  Stop uploads and reset their timers, block scheduler requests.  Downloads will be completed.") 
     615                ); 
     616            } 
     617        } 
    564618        m_pTaskPane->EnableTask(pGroup->m_Tasks[BTN_NOWORK]); 
    565619        if (project) { 
    566620            if (project->dont_request_more_work) { 
     
    673727        if (project->suspended_via_gui) { 
    674728            append_to_status(status, _("Suspended by user")); 
    675729        } 
     730        else if (project->network_suspended_via_gui && project->sched_rpc_pending != RPC_REASON_USER_REQ) { 
     731            append_to_status(status, _("Network activity suspended by user")); 
     732        } 
    676733        if (project->dont_request_more_work) { 
    677734            append_to_status(status, _("Won't get new tasks")); 
    678735        } 
     
    684741        } 
    685742        if (project->sched_rpc_pending) { 
    686743            append_to_status(status, _("Scheduler request pending")); 
    687                        append_to_status(status, wxString(rpc_reason_string(project->sched_rpc_pending), wxConvUTF8)); 
     744            append_to_status(status, wxString(rpc_reason_string(project->sched_rpc_pending), wxConvUTF8)); 
    688745        } 
     746        if (project->trickle_up_pending && 
     747            !project->scheduler_rpc_in_progress && 
     748            project->sched_rpc_pending != RPC_REASON_TRICKLE_UP) { 
     749            append_to_status(status, _("Trickle upload pending")); 
     750        } 
    689751        if (project->scheduler_rpc_in_progress) { 
    690752            append_to_status(status, _("Scheduler request in progress")); 
    691753        } 
  • clientgui/ViewProjectsBase.h

    old new  
    5858 
    5959    void                    OnProjectUpdate( wxCommandEvent& event ); 
    6060    void                    OnProjectSuspend( wxCommandEvent& event ); 
     61    void                    OnProjectSuspendNetwork( wxCommandEvent& event ); 
    6162    void                    OnProjectNoNewWork( wxCommandEvent& event ); 
    6263    void                    OnProjectReset( wxCommandEvent& event ); 
    6364    void                    OnProjectDetach( wxCommandEvent& event ); 
  • clientgui/ViewProjectsGrid.cpp

    old new  
    4949#define GRP_WEBSITES 1 
    5050 
    5151// buttons in the "tasks" area 
    52 #define BTN_UPDATE       0 
    53 #define BTN_SUSPEND      1 
    54 #define BTN_NOWORK       2 
    55 #define BTN_RESET        3 
    56 #define BTN_DETACH       4 
     52#define BTN_UPDATE            0 
     53#define BTN_SUSPEND           1 
     54#define BTN_SUSPEND_NETWORK   2 
     55#define BTN_NOWORK            3 
     56#define BTN_RESET             4 
     57#define BTN_DETACH            5 
    5758 
    5859 
    5960IMPLEMENT_DYNAMIC_CLASS(CViewProjectsGrid, CBOINCBaseView) 
     
    6162BEGIN_EVENT_TABLE (CViewProjectsGrid, CBOINCBaseView) 
    6263    EVT_BUTTON(ID_TASK_PROJECT_UPDATE, CViewProjectsGrid::OnProjectUpdate) 
    6364    EVT_BUTTON(ID_TASK_PROJECT_SUSPEND, CViewProjectsGrid::OnProjectSuspend) 
     65    EVT_BUTTON(ID_TASK_PROJECT_SUSPEND_NETWORK, CViewProjectsGrid::OnProjectSuspendNetwork) 
    6466    EVT_BUTTON(ID_TASK_PROJECT_NONEWWORK, CViewProjectsGrid::OnProjectNoNewWork) 
    6567    EVT_BUTTON(ID_TASK_PROJECT_RESET, CViewProjectsGrid::OnProjectReset) 
    6668    EVT_BUTTON(ID_TASK_PROJECT_DETACH, CViewProjectsGrid::OnProjectDetach) 
     
    130132    ); 
    131133    pGroup->m_Tasks.push_back( pItem ); 
    132134 
     135    pItem = new CTaskItem( 
     136        _("Suspend network"), 
     137        _("Suspend network activity for this project.  Stop uploads and reset their timers, block scheduler requests.  Downloads will be completed."), 
     138        ID_TASK_PROJECT_SUSPEND_NETWORK 
     139    ); 
     140    pGroup->m_Tasks.push_back( pItem ); 
     141 
    133142        pItem = new CTaskItem( 
    134143        _("No new tasks"), 
    135144        _("Don't get new tasks for this project."), 
     
    285294} 
    286295 
    287296 
     297void CViewProjectsGrid::OnProjectSuspendNetwork( wxCommandEvent& WXUNUSED(event) ) { 
     298    wxLogTrace(wxT("Function Start/End"), wxT("CViewProjectsGrid::OnProjectSuspendNetwork - Function Begin")); 
     299 
     300    wxString        strProjectURL  = wxEmptyString; 
     301    CMainDocument*  pDoc           = wxGetApp().GetDocument(); 
     302    CAdvancedFrame* pFrame         = wxDynamicCast(GetParent()->GetParent()->GetParent(), CAdvancedFrame); 
     303    int i, n; 
     304 
     305    wxASSERT(pDoc); 
     306    wxASSERT(wxDynamicCast(pDoc, CMainDocument)); 
     307    wxASSERT(pFrame); 
     308    wxASSERT(wxDynamicCast(pFrame, CAdvancedFrame)); 
     309    wxASSERT(m_pGridPane); 
     310 
     311    wxArrayInt arrSelRows = m_pGridPane->GetSelectedRows2(); 
     312    n = (int)arrSelRows.GetCount(); 
     313    for(i=0; i<n; i++) { 
     314        strProjectURL =  
     315            HtmlEntityEncode( 
     316                m_pGridPane->GetCellValue( 
     317                    arrSelRows[i], 
     318                    COLUMN_HIDDEN_URL 
     319                ).Trim(false) 
     320            ); 
     321        PROJECT* project = pDoc->project(strProjectURL); 
     322         
     323        if (project->network_suspended_via_gui) { 
     324            pFrame->UpdateStatusText(_("Resuming project network activity...")); 
     325            pDoc->ProjectResumeNetwork(strProjectURL); 
     326        } else { 
     327            pFrame->UpdateStatusText(_("Suspending project network activity...")); 
     328            pDoc->ProjectSuspendNetwork(strProjectURL); 
     329        } 
     330    } 
     331    pFrame->UpdateStatusText(wxT("")); 
     332 
     333    m_bForceUpdateSelection = true; 
     334    UpdateSelection(); 
     335    pFrame->FireRefreshView(); 
     336 
     337    wxLogTrace(wxT("Function Start/End"), wxT("CViewProjectsGrid::OnProjectSuspendNetwork - Function End")); 
     338} 
     339 
     340 
    288341void CViewProjectsGrid::OnProjectNoNewWork( wxCommandEvent& WXUNUSED(event) ) { 
    289342    wxLogTrace(wxT("Function Start/End"), wxT("CViewProjectsGrid::OnProjectNoNewWork - Function Begin")); 
    290343 
     
    496549    PROJECT*        project = NULL; 
    497550    CMainDocument*  pDoc = wxGetApp().GetDocument(); 
    498551    int             i, n; 
    499     bool            wasSuspended=false, wasNoNewWork=false; 
     552    bool            wasSuspended=false, wasNetworkSuspended=false, wasNoNewWork=false; 
    500553    static int      lastCount = 0; 
    501554 
    502555    wxASSERT(pDoc); 
     
    569622        } 
    570623 
    571624        if (i == 0) { 
     625            wasNetworkSuspended = project->network_suspended_via_gui; 
     626             if (project->network_suspended_via_gui) { 
     627                m_pTaskPane->UpdateTask( 
     628                    pGroup->m_Tasks[BTN_SUSPEND_NETWORK], _("Resume network"), _("Resume network activity for this project.") 
     629                ); 
     630            } else { 
     631                m_pTaskPane->UpdateTask( 
     632                    pGroup->m_Tasks[BTN_SUSPEND_NETWORK], 
     633                    _("Suspend network"), 
     634                    _("Suspend network activity for this project.  Stop uploads and reset their timers, block scheduler requests.  Downloads will be completed.") 
     635                ); 
     636            } 
     637        } else { 
     638            if (wasNetworkSuspended != project->network_suspended_via_gui) { 
     639                // Disable Suspend / Resume button if the multiple selection 
     640                // has a mix of suspended and not suspended projects 
     641                m_pTaskPane->DisableTask(pGroup->m_Tasks[BTN_SUSPEND_NETWORK]); 
     642            } 
     643        } 
     644 
     645        if (i == 0) { 
    572646            wasNoNewWork = project->dont_request_more_work; 
    573647            if (project->dont_request_more_work) { 
    574648                m_pTaskPane->UpdateTask( 
     
    727801        if (project->suspended_via_gui) { 
    728802            append_to_status(strBuffer, _("Suspended by user")); 
    729803        } 
     804        else if (project->network_suspended_via_gui && project->sched_rpc_pending != RPC_REASON_USER_REQ) { 
     805            append_to_status(strBuffer, _("Network activity suspended by user")); 
     806        } 
    730807        if (project->dont_request_more_work) { 
    731808            append_to_status(strBuffer, _("Won't get new tasks")); 
    732809        } 
     
    738815        } 
    739816        if (project->sched_rpc_pending) { 
    740817            append_to_status(strBuffer, _("Scheduler request pending")); 
    741                        append_to_status(strBuffer, wxString(rpc_reason_string(project->sched_rpc_pending), wxConvUTF8)); 
     818            append_to_status(strBuffer, wxString(rpc_reason_string(project->sched_rpc_pending), wxConvUTF8)); 
    742819        } 
     820        if (project->trickle_up_pending && 
     821            !project->scheduler_rpc_in_progress && 
     822            project->sched_rpc_pending != RPC_REASON_TRICKLE_UP) { 
     823            append_to_status(strBuffer, _("Trickle upload pending")); 
     824        } 
    743825        if (project->scheduler_rpc_in_progress) { 
    744826            append_to_status(strBuffer, _("Scheduler request in progress")); 
    745827        } 
  • clientgui/ViewProjectsGrid.h

    old new  
    4747    void                    OnProjectUpdate( wxCommandEvent& event ); 
    4848    void                    OnProjectSuspend( wxCommandEvent& event ); 
    4949    void                    OnProjectNoNewWork( wxCommandEvent& event ); 
     50    void                    OnProjectSuspendNetwork( wxCommandEvent& event ); 
    5051    void                    OnProjectReset( wxCommandEvent& event ); 
    5152    void                    OnProjectDetach( wxCommandEvent& event ); 
    5253 
  • clientgui/ViewTransfers.cpp

    old new  
    440440 
    441441void CViewTransfers::UpdateSelection() { 
    442442    CTaskItemGroup* pGroup = m_TaskGroups[0]; 
     443    CMainDocument*  pDoc = wxGetApp().GetDocument(); 
     444    FILE_TRANSFER*  transfer; 
     445    int             i, n, row; 
     446    bool            enableButtons = false; 
    443447 
     448    wxASSERT(pDoc); 
     449    wxASSERT(wxDynamicCast(pDoc, CMainDocument)); 
     450    wxASSERT(m_pTaskPane); 
     451    wxASSERT(m_pListPane); 
     452 
    444453    CBOINCBaseView::PreUpdateSelection(); 
    445454 
    446     if (m_pListPane->GetSelectedItemCount()) { 
     455    n = m_pListPane->GetSelectedItemCount(); 
     456    if (n > 0) { 
     457        enableButtons = true; 
     458    } 
     459 
     460    row = -1; 
     461    for (i=0; i<n; i++) { 
     462        // Step through all selected items 
     463        row = m_pListPane->GetNextItem(row, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED); 
     464        if (row < 0) break;     // Should never happen 
     465 
     466        transfer = pDoc->file_transfer(m_iSortedIndexes[row]); 
     467        if (transfer && 
     468            transfer->project && 
     469            transfer->project->network_suspended_via_gui) { 
     470            enableButtons = false; 
     471            break; 
     472        } 
     473    } 
     474 
     475    if (enableButtons) { 
    447476        m_pTaskPane->EnableTaskGroupTasks(pGroup); 
    448477    } else { 
    449478        m_pTaskPane->DisableTaskGroupTasks(pGroup); 
     
    758787            } else { 
    759788                if (transfer->xfer_active) { 
    760789                    strBuffer = transfer->generated_locally? _("Uploading") : _("Downloading"); 
     790                } else if (transfer->generated_locally) { 
     791                    strBuffer = _("Upload pending"); 
     792                    if (transfer->project != NULL && transfer->project->network_suspended_via_gui) { 
     793                        strBuffer += _(", project networking suspended"); 
     794                    } 
    761795                } else { 
    762                     strBuffer = transfer->generated_locally? _("Upload pending") : _("Download pending"); 
     796                    strBuffer = _("Download pending"); 
    763797                } 
    764798            } 
    765799        } 
     
    779813 
    780814    if (transfer) { 
    781815        strBuffer = wxString(transfer->project_url.c_str(), wxConvUTF8); 
     816        transfer->project = pDoc->state.lookup_project(transfer->project_url); 
    782817    } 
    783818} 
    784819 
  • clientgui/ViewTransfersGrid.cpp

    old new  
    253253 
    254254void CViewTransfersGrid::UpdateSelection() { 
    255255    CTaskItemGroup* pGroup = m_TaskGroups[0]; 
     256    CMainDocument*  pDoc = wxGetApp().GetDocument(); 
     257    FILE_TRANSFER*  transfer; 
     258    int             i, n, row; 
     259    bool            enableButtons = false; 
    256260 
     261    wxASSERT(pDoc); 
     262    wxASSERT(wxDynamicCast(pDoc, CMainDocument)); 
     263    wxASSERT(m_pTaskPane); 
     264    wxASSERT(m_pListPane); 
     265 
    257266    CBOINCBaseView::PreUpdateSelection(); 
    258267 
    259         if (m_pGridPane->GetSelectedRows2().size() > 0) { 
     268    n = m_pListPane->GetSelectedItemCount(); 
     269    if (n > 0) { 
     270        enableButtons = true; 
     271    } 
     272 
     273    row = -1; 
     274    for (i=0; i<n; i++) { 
     275        // Step through all selected items 
     276        row = m_pListPane->GetNextItem(row, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED); 
     277        if (row < 0) break;     // Should never happen 
     278 
     279        transfer = pDoc->file_transfer(m_iSortedIndexes[row]); 
     280        if (transfer && 
     281            transfer->project && 
     282            transfer->project->network_suspended_via_gui) { 
     283            enableButtons = false; 
     284            break; 
     285        } 
     286    } 
     287 
     288    if (enableButtons) { 
    260289        m_pTaskPane->EnableTaskGroupTasks(pGroup); 
    261290    } else { 
    262291        m_pTaskPane->DisableTaskGroupTasks(pGroup); 
     
    427456            } else { 
    428457                if (transfer->xfer_active) { 
    429458                    strBuffer = transfer->generated_locally? _("Uploading") : _("Downloading"); 
     459                } else if (transfer->generated_locally) { 
     460                    strBuffer = _("Upload pending"); 
     461                    if (transfer->project != NULL && transfer->project->network_suspended_via_gui) { 
     462                        strBuffer += _(", project networking suspended"); 
     463                    } 
    430464                } else { 
    431                     strBuffer = transfer->generated_locally? _("Upload pending") : _("Download pending"); 
     465                    strBuffer = _("Download pending"); 
    432466                } 
    433467            } 
    434468        } 
     
    447481 
    448482    if (transfer) { 
    449483        strBuffer = wxString(transfer->project_url.c_str(), wxConvUTF8); 
     484        transfer->project = pDoc->state.lookup_project(transfer->project_url); 
    450485    } 
    451486 
    452487    return 0; 
  • clientgui/ViewWork.cpp

    old new  
    10851085        if (result->ready_to_report) { 
    10861086            strBuffer += _("Upload failed"); 
    10871087        } else { 
     1088            PROJECT* project; 
     1089 
    10881090            strBuffer += _("Uploading"); 
     1091            project = doc->state.lookup_project(result->project_url); 
     1092            if (project->network_suspended_via_gui) 
     1093            { 
     1094                strBuffer += _(", project networking suspended"); 
     1095            } 
    10891096        } 
    10901097        break; 
    10911098    case RESULT_ABORTED: 
  • clientgui/ViewWorkGrid.cpp

    old new  
    838838        if (result->ready_to_report) { 
    839839            strBuffer = _("Upload failed"); 
    840840        } else { 
    841             strBuffer = _("Uploading"); 
     841            PROJECT* project; 
     842 
     843            strBuffer += _("Uploading"); 
     844            project = doc->state.lookup_project(result->project_url); 
     845            if (project->network_suspended_via_gui) 
     846            { 
     847                strBuffer += _(", project networking suspended"); 
     848            } 
    842849        } 
    843850        break; 
    844851    case RESULT_ABORTED: 
  • lib/gui_rpc_client.h

    old new  
    119119 
    120120    bool master_url_fetch_pending; // need to fetch and parse the master URL 
    121121    int sched_rpc_pending;      // need to contact scheduling server 
     122    bool trickle_up_pending;    // need to upload trickles 
    122123    bool non_cpu_intensive; 
    123124    bool suspended_via_gui; 
     125    bool network_suspended_via_gui; 
    124126    bool dont_request_more_work; 
    125127    bool scheduler_rpc_in_progress; 
    126128    bool attached_via_acct_mgr; 
  • lib/gui_rpc_client_ops.cpp

    old new  
    206206        if (parse_double(buf, "<duration_correction_factor>", duration_correction_factor)) continue; 
    207207        if (parse_bool(buf, "master_url_fetch_pending", master_url_fetch_pending)) continue; 
    208208        if (parse_int(buf, "<sched_rpc_pending>", sched_rpc_pending)) continue; 
     209        if (parse_bool(buf, "trickle_up_pending", trickle_up_pending)) continue; 
    209210        if (parse_bool(buf, "non_cpu_intensive", non_cpu_intensive)) continue; 
    210211        if (parse_bool(buf, "suspended_via_gui", suspended_via_gui)) continue; 
     212        if (parse_bool(buf, "network_suspended_via_gui", network_suspended_via_gui)) continue; 
    211213        if (parse_bool(buf, "dont_request_more_work", dont_request_more_work)) continue; 
    212214        if (parse_bool(buf, "ended", ended)) continue; 
    213215        if (parse_bool(buf, "scheduler_rpc_in_progress", scheduler_rpc_in_progress)) continue; 
     
    256258    duration_correction_factor = 0; 
    257259    master_url_fetch_pending = false; 
    258260    sched_rpc_pending = 0; 
     261    trickle_up_pending = false; 
    259262    ended = false; 
    260263    non_cpu_intensive = false; 
    261264    suspended_via_gui = false; 
     265    network_suspended_via_gui = false; 
    262266    dont_request_more_work = false; 
    263267    scheduler_rpc_in_progress = false; 
    264268    attached_via_acct_mgr = false; 
     
    14881492    } else if (!strcmp(op, "resume")) { 
    14891493        tag = "project_resume"; 
    14901494        project.suspended_via_gui = false; 
     1495    } else if (!strcmp(op, "network_suspend")) { 
     1496        tag = "project_network_suspend"; 
     1497        project.network_suspended_via_gui = true; 
     1498    } else if (!strcmp(op, "network_resume")) { 
     1499        tag = "project_network_resume"; 
     1500        project.network_suspended_via_gui = false; 
    14911501    } else if (!strcmp(op, "allowmorework")) { 
    14921502        tag = "project_allowmorework"; 
    14931503        project.dont_request_more_work = false; 
  • lib/gui_rpc_client_print.cpp

    old new  
    7474    printf("   master_fetch_failures: %d\n", master_fetch_failures); 
    7575    printf("   master fetch pending: %s\n", master_url_fetch_pending?"yes":"no"); 
    7676    printf("   scheduler RPC pending: %s\n", sched_rpc_pending?"yes":"no"); 
     77    printf("   trickle upload pending: %s\n", trickle_up_pending?"yes":"no"); 
    7778    printf("   attached via Account Manager: %s\n", attached_via_acct_mgr?"yes":"no"); 
    7879    printf("   ended: %s\n", ended?"yes":"no"); 
    7980    printf("   suspended via GUI: %s\n", suspended_via_gui?"yes":"no"); 
     81    printf("   network activity suspended via GUI: %s\n", network_suspended_via_gui?"yes":"no"); 
    8082    printf("   don't request more work: %s\n", dont_request_more_work?"yes":"no"); 
    8183    printf("   disk usage: %f\n", disk_usage); 
    8284    printf("   last RPC: %f\n", last_rpc_time); 

If this page is incomplete or incorrect, please edit it or add it to the wiki to-do list. To do this, you must be logged in; click Login or Register above.