Ticket #139: trac139_trunk.patch

File trac139_trunk.patch, 47.6 KB (added by Thyme Lawn, 15 years ago)

Patch for boinc_trunk (revision 18844)

  • client/boinc_cmd.cpp

     
    7474 --result url result_name op        job operation\n\
    7575   op = suspend | resume | abort | graphics_window | graphics_fullscreen\n\
    7676 --project URL op                   project operation\n\
    77    op = reset | detach | update | suspend | resume | nomorework | allowmorework\n\
     77   op = reset | detach | update | suspend | resume | network_suspend | network_resume | nomorework | allowmorework\n\
    7878 --file_transfer URL filename op    file transfer operation\n\
    7979   op = retry | abort\n\
    8080 --set_run_mode mode duration       set run mode for given duration\n\
    … …  
    270270            retval = rpc.project_op(project, "suspend");
    271271        } else if (!strcmp(op, "resume")) {
    272272            retval = rpc.project_op(project, "resume");
     273        } else if (!strcmp(op, "network_suspend")) {
     274            retval = rpc.project_op(project, "network_suspend");
     275        } else if (!strcmp(op, "network_resume")) {
     276            retval = rpc.project_op(project, "network_resume");
    273277        } else if (!strcmp(op, "detach")) {
    274278            retval = rpc.project_op(project, "detach");
    275279        } else if (!strcmp(op, "update")) {
    276280            retval = rpc.project_op(project, "update");
    277         } else if (!strcmp(op, "suspend")) {
    278             retval = rpc.project_op(project, "suspend");
    279         } else if (!strcmp(op, "resume")) {
    280             retval = rpc.project_op(project, "resume");
    281281        } else if (!strcmp(op, "nomorework")) {
    282282            retval = rpc.project_op(project, "nomorework");
    283283        } else if (!strcmp(op, "allowmorework")) {

  • client/client_types.cpp

     
    103103    send_time_stats_log = 0;
    104104    send_job_log = 0;
    105105    suspended_via_gui = false;
     106    network_suspended_via_gui = false;
    106107    dont_request_more_work = false;
    107108    detach_when_done = false;
    108109    attached_via_acct_mgr = false;
    … …  
    182183        if (parse_bool(buf, "non_cpu_intensive", non_cpu_intensive)) continue;
    183184        if (parse_bool(buf, "verify_files_on_app_start", verify_files_on_app_start)) continue;
    184185        if (parse_bool(buf, "suspended_via_gui", suspended_via_gui)) continue;
     186        if (parse_bool(buf, "network_suspended_via_gui", network_suspended_via_gui)) continue;
    185187        if (parse_bool(buf, "dont_request_more_work", dont_request_more_work)) continue;
    186188        if (parse_bool(buf, "detach_when_done", detach_when_done)) continue;
    187189        if (parse_bool(buf, "ended", ended)) continue;
    … …  
    254256                "    <sched_rpc_pending>%d</sched_rpc_pending>\n"
    255257                "    <send_time_stats_log>%d</send_time_stats_log>\n"
    256258                "    <send_job_log>%d</send_job_log>\n"
    257         "%s%s%s%s%s%s%s%s%s%s%s%s",
     259        "%s%s%s%s%s%s%s%s%s%s%s%s%s",
    258260        master_url,
    259261        project_name,
    260262        symstore,
    … …  
    290292        non_cpu_intensive?"    <non_cpu_intensive/>\n":"",
    291293        verify_files_on_app_start?"    <verify_files_on_app_start/>\n":"",
    292294        suspended_via_gui?"    <suspended_via_gui/>\n":"",
     295        network_suspended_via_gui?"    <network_suspended_via_gui/>\n":"",
    293296        dont_request_more_work?"    <dont_request_more_work/>\n":"",
    294297        detach_when_done?"    <detach_when_done/>\n":"",
    295298        ended?"    <ended/>\n":"",
    … …  
    378381    non_cpu_intensive = p.non_cpu_intensive;
    379382    verify_files_on_app_start = p.verify_files_on_app_start;
    380383    suspended_via_gui = p.suspended_via_gui;
     384    network_suspended_via_gui = p.network_suspended_via_gui;
    381385    dont_request_more_work = p.dont_request_more_work;
    382386    detach_when_done = p.detach_when_done;
    383387    attached_via_acct_mgr = p.attached_via_acct_mgr;

  • client/client_types.h

     
    288288    int send_job_log;
    289289
    290290    bool suspended_via_gui;
     291    bool network_suspended_via_gui;
    291292        /// Return work, but don't request more
    292293        /// Used for a clean exit to a project,
    293294        /// or if a user wants to pause doing work for the project

  • client/cs_files.cpp

     
    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

     
    10081008        p = projects[i];
    10091009        if (p->waiting_until_min_rpc_time()) continue;
    10101010        if (p->suspended_via_gui) continue;
     1011        if (p->network_suspended_via_gui) continue;
    10111012        if (p->master_url_fetch_pending) {
    10121013            return p;
    10131014        }
    … …  
    10601061        if (honor_suspend && p->suspended_via_gui) {
    10611062            continue;
    10621063        }
     1064        if (honor_suspend && p->network_suspended_via_gui) {
     1065            continue;
     1066        }
    10631067        if (p->sched_rpc_pending) {
    10641068            return p;
    10651069        }
    … …  
    10751079        p = projects[i];
    10761080        if (p->waiting_until_min_rpc_time()) continue;
    10771081        if (p->suspended_via_gui) continue;
     1082        if (p->network_suspended_via_gui) continue;
    10781083        if (p->trickle_up_pending) {
    10791084            return p;
    10801085        }
    … …  
    11011106        PROJECT* p = r->project;
    11021107        if (p->waiting_until_min_rpc_time()) continue;
    11031108        if (p->suspended_via_gui) continue;
     1109        if (p->network_suspended_via_gui) continue;
    11041110
    11051111        if (config.report_results_immediately) {
    11061112            return p;

  • client/gui_rpc_server_ops.cpp

     
    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,
    … …  
    11831189        handle_project_op(request_msg, mf, "suspend");
    11841190    } else if (match_tag(request_msg, "<project_resume")) {
    11851191        handle_project_op(request_msg, mf, "resume");
     1192    } else if (match_tag(request_msg, "<project_network_suspend")) {
     1193        handle_project_op(request_msg, mf, "network_suspend");
     1194    } else if (match_tag(request_msg, "<project_network_resume")) {
     1195        handle_project_op(request_msg, mf, "network_resume");
    11861196    } else if (match_tag(request_msg, "<set_run_mode")) {
    11871197        handle_set_run_mode(request_msg, mf);
    11881198    } else if (match_tag(request_msg, "<quit")) {

  • client/scheduler_op.cpp

     
    211211int SCHEDULER_OP::start_rpc(PROJECT* p) {
    212212    int retval;
    213213    char request_file[1024], reply_file[1024], buf[256];
     214    char *trickle_up_msg;
    214215
    215216    safe_strcpy(scheduler_url, p->get_scheduler_url(url_index, url_random));
    216217    if (log_flags.sched_ops) {
    217218        msg_printf(p, MSG_INFO,
    218219            "Sending scheduler request: %s.", rpc_reason_string(reason)
    219220        );
     221        if (p->trickle_up_pending && reason != RPC_REASON_TRICKLE_UP) {
     222            trickle_up_msg = ", sending trickle-up message";
     223        } else {
     224            trickle_up_msg = "";
     225        }
    220226        if (cpu_work_fetch.req_secs || cuda_work_fetch.req_secs) {
    221227            if (coproc_cuda) {
    222228                if (cpu_work_fetch.req_secs && cuda_work_fetch.req_secs) {
    … …  
    231237            }
    232238            if (p->nresults_returned) {
    233239                msg_printf(p, MSG_INFO,
    234                     "Reporting %d completed tasks, requesting new tasks%s",
    235                     p->nresults_returned, buf
     240                    "Reporting %d completed tasks, requesting new tasks%s%s",
     241                    p->nresults_returned, buf, trickle_up_msg
    236242                );
    237243            } else {
    238                 msg_printf(p, MSG_INFO, "Requesting new tasks%s", buf);
     244                msg_printf(p, MSG_INFO, "Requesting new tasks%s%s", buf, trickle_up_msg);
    239245            }
    240246        } else {
    241247            if (p->nresults_returned) {
    242248                msg_printf(p, MSG_INFO,
    243                     "Reporting %d completed tasks, not requesting new tasks",
    244                     p->nresults_returned
     249                    "Reporting %d completed tasks, not requesting new tasks%s",
     250                    p->nresults_returned, trickle_up_msg
    245251                );
    246252            } else {
    247                 msg_printf(p, MSG_INFO, "Not reporting or requesting tasks");
     253                msg_printf(p, MSG_INFO, "Not reporting or requesting tasks%s", trickle_up_msg);
    248254            }
    249255        }
    250256    }

  • client/sim_util.cpp

     
    141141    short_term_debt = 0;
    142142    send_file_list = false;
    143143    suspended_via_gui = false;
     144    network_suspended_via_gui = false;
    144145    dont_request_more_work = false;
    145146    detach_when_done = false;
    146147    attached_via_acct_mgr = false;

  • client/work_fetch.cpp

     
    106106bool PROJECT_WORK_FETCH::compute_can_fetch_work(PROJECT* p) {
    107107    if (p->non_cpu_intensive) return false;
    108108    if (p->suspended_via_gui) return false;
     109    if (p->network_suspended_via_gui && p->sched_rpc_pending != RPC_REASON_USER_REQ) return false;
    109110    if (p->master_url_fetch_pending) return false;
    110111    if (p->min_rpc_time > gstate.now) return false;
    111112    if (p->dont_request_more_work) return false;
    … …  
    308309        RSC_PROJECT_WORK_FETCH& pwf = project_state(p);
    309310        double bt = pwf.backoff_time>gstate.now?pwf.backoff_time-gstate.now:0;
    310311        msg_printf(p, MSG_INFO,
    311             "[wfd] %s: fetch share %.2f debt %.2f backoff dt %.2f int %.2f%s%s%s%s%s%s",
     312            "[wfd] %s: fetch share %.2f debt %.2f backoff dt %.2f int %.2f%s%s%s%s%s%s%s",
    312313            name,
    313314            pwf.fetchable_share, pwf.debt, bt, pwf.backoff_interval,
    314315            p->suspended_via_gui?" (susp via GUI)":"",
     316            p->network_suspended_via_gui?" (net susp via GUI)":"",
    315317            p->master_url_fetch_pending?" (master fetch pending)":"",
    316318            p->min_rpc_time > gstate.now?" (comm deferred)":"",
    317319            p->dont_request_more_work?" (no new tasks)":"",
    … …  
    829831
    830832bool PROJECT::can_request_work() {
    831833    if (suspended_via_gui) return false;
     834    if (network_suspended_via_gui && sched_rpc_pending != RPC_REASON_USER_REQ) return false;
    832835    if (master_url_fetch_pending) return false;
    833836    if (min_rpc_time > gstate.now) return false;
    834837    if (dont_request_more_work) return false;

  • clientgui/DlgItemProperties.cpp

     
    120120    addProperty(_("Computer ID"), wxString::Format(wxT("%d"), project->hostid));
    121121        addProperty(_("Non CPU intensive"),project->non_cpu_intensive ? _("yes") : _("no"));
    122122        addProperty(_("Suspended via GUI"),project->suspended_via_gui ? _("yes") : _("no"));
     123        addProperty(_("Network activity suspended via GUI"),project->network_suspended_via_gui ? _("yes") : _("no"));
    123124        addProperty(_("Don't request more work"),project->dont_request_more_work ? _("yes") : _("no"));
    124125        addProperty(_("Scheduler call in progress"),project->scheduler_rpc_in_progress ? _("yes") : _("no"));
     126        addProperty(_("Trickle-up pending"),project->trickle_up_pending ? _("yes") : _("no"));
    125127        addProperty(_("Attached via account manager"),project->attached_via_acct_mgr ? _("yes") : _("no"));
    126128        addProperty(_("Detach when done"),project->detach_when_done ? _("yes") : _("no"));
    127129        addProperty(_("Ended"),project->ended ? _("yes") : _("no"));

  • clientgui/Events.h

     
    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_ACTIVE_ONLY                     9200

  • clientgui/MainDocument.cpp

     
    13371337    return iRetVal;
    13381338}
    13391339
     1340int CMainDocument::ProjectSuspendNetwork(int iIndex) {
     1341    PROJECT* pProject = NULL;
     1342    int iRetVal = -1;
     1343
     1344    pProject = project(iIndex);
     1345
     1346    if (pProject)
     1347        iRetVal = rpc.project_op((*pProject), "network_suspend");
     1348
     1349    return iRetVal;
     1350}
     1351
     1352int CMainDocument::ProjectSuspendNetwork(const wxString& projectname) {
     1353    PROJECT* pProject = NULL;
     1354    int iRetVal = -1;
     1355
     1356    pProject = project(projectname);
     1357
     1358    if (pProject)
     1359        iRetVal = rpc.project_op((*pProject), "network_suspend");
     1360
     1361    return iRetVal;
     1362}
     1363
     1364int CMainDocument::ProjectResumeNetwork(int iIndex) {
     1365    PROJECT* pProject = NULL;
     1366    int iRetVal = -1;
     1367
     1368    pProject = project(iIndex);
     1369
     1370    if (pProject)
     1371        iRetVal = rpc.project_op((*pProject), "network_resume");
     1372
     1373    return iRetVal;
     1374}
     1375
     1376int CMainDocument::ProjectResumeNetwork(const wxString& projectname) {
     1377    PROJECT* pProject = NULL;
     1378    int iRetVal = -1;
     1379
     1380    pProject = project(projectname);
     1381
     1382    if (pProject)
     1383        iRetVal = rpc.project_op((*pProject), "network_resume");
     1384
     1385    return iRetVal;
     1386}
     1387
    13401388int CMainDocument::ProjectNoMoreWork(int iIndex) {
    13411389    PROJECT* pProject = NULL;
    13421390    int iRetVal = -1;

  • clientgui/MainDocument.h

     
    230230        int                         ProjectSuspend(const wxString& projectname);
    231231    int                         ProjectResume(int iIndex);
    232232        int                         ProjectResume(const wxString& projectname);
     233    int                         ProjectSuspendNetwork(int iIndex);
     234        int                         ProjectSuspendNetwork(const wxString& projectname);
     235    int                         ProjectResumeNetwork(int iIndex);
     236        int                         ProjectResumeNetwork(const wxString& projectname);
    233237
    234238
    235239    //

  • clientgui/ViewProjects.cpp

     
    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

     
    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

     
    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

     
    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

     
    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

     
    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

     
    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        }
    … …  
    784818
    785819    if (transfer) {
    786820        strBuffer = wxString(transfer->project_url.c_str(), wxConvUTF8);
     821        transfer->project = pDoc->state.lookup_project(transfer->project_url);
    787822    }
    788823}
    789824

  • clientgui/ViewTransfersGrid.cpp

     
    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

     
    11791179        if (result->ready_to_report) {
    11801180            strBuffer += _("Upload failed");
    11811181        } else {
     1182            PROJECT* project;
     1183
    11821184            strBuffer += _("Uploading");
     1185            project = doc->state.lookup_project(result->project_url);
     1186            if (project->network_suspended_via_gui)
     1187            {
     1188                strBuffer += _(", project networking suspended");
     1189            }
    11831190        }
    11841191        break;
    11851192    case RESULT_ABORTED:

  • clientgui/ViewWorkGrid.cpp

     
    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

     
    133133
    134134    bool master_url_fetch_pending; // need to fetch and parse the master URL
    135135    int sched_rpc_pending;      // need to contact scheduling server
     136    bool trickle_up_pending;    // need to upload trickles
    136137    bool non_cpu_intensive;
    137138    bool suspended_via_gui;
     139    bool network_suspended_via_gui;
    138140    bool dont_request_more_work;
    139141    bool scheduler_rpc_in_progress;
    140142    bool attached_via_acct_mgr;

  • lib/gui_rpc_client_ops.cpp

     
    248248        if (parse_double(buf, "<duration_correction_factor>", duration_correction_factor)) continue;
    249249        if (parse_bool(buf, "master_url_fetch_pending", master_url_fetch_pending)) continue;
    250250        if (parse_int(buf, "<sched_rpc_pending>", sched_rpc_pending)) continue;
     251        if (parse_bool(buf, "trickle_up_pending", trickle_up_pending)) continue;
    251252        if (parse_bool(buf, "non_cpu_intensive", non_cpu_intensive)) continue;
    252253        if (parse_bool(buf, "suspended_via_gui", suspended_via_gui)) continue;
     254        if (parse_bool(buf, "network_suspended_via_gui", network_suspended_via_gui)) continue;
    253255        if (parse_bool(buf, "dont_request_more_work", dont_request_more_work)) continue;
    254256        if (parse_bool(buf, "ended", ended)) continue;
    255257        if (parse_bool(buf, "scheduler_rpc_in_progress", scheduler_rpc_in_progress)) continue;
    … …  
    300302    duration_correction_factor = 0;
    301303    master_url_fetch_pending = false;
    302304    sched_rpc_pending = 0;
     305    trickle_up_pending = false;
    303306    ended = false;
    304307    non_cpu_intensive = false;
    305308    suspended_via_gui = false;
     309    network_suspended_via_gui = false;
    306310    dont_request_more_work = false;
    307311    scheduler_rpc_in_progress = false;
    308312    attached_via_acct_mgr = false;
    … …  
    15121516    } else if (!strcmp(op, "resume")) {
    15131517        tag = "project_resume";
    15141518        project.suspended_via_gui = false;
     1519    } else if (!strcmp(op, "network_suspend")) {
     1520        tag = "project_network_suspend";
     1521        project.network_suspended_via_gui = true;
     1522    } else if (!strcmp(op, "network_resume")) {
     1523        tag = "project_network_resume";
     1524        project.network_suspended_via_gui = false;
    15151525    } else if (!strcmp(op, "allowmorework")) {
    15161526        tag = "project_allowmorework";
    15171527        project.dont_request_more_work = false;

  • lib/gui_rpc_client_print.cpp

     
    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);