Ticket #139: trac139_6_8.patch

File trac139_6_8.patch, 48.1 KB (added by Thyme Lawn, 15 years ago)

Patch for boinc_core_release_6_8 (revision 18844)

  • client/boinc_cmd.cpp

     
    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

     
    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

     
    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

     
    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

     
    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

     
    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

     
    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

     
    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

     
    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

     
    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

     
    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

     
    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

     
    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

     
    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

     
    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        }
    … …  
    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

     
    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

     
    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

     
    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

     
    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

     
    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

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