← Back to branch summary

~ubuntu-branches/ubuntu/trusty/powerd/trusty

« back to all changes in this revision

Viewing changes to cli/powerd-cli.c

  • Committer: Package Import Robot
  • Author(s): Ubuntu daily release, Seth Forshee, Ubuntu daily release
  • Date: 2013-08-02 02:01:55 UTC
  • mfrom: (1.1.14)
  • Revision ID: package-import@ubuntu.com-20130802020155-hatl1xtajxn6qdui
Tags: 0.13+13.10.20130802-0ubuntu1
[ Seth Forshee ]
* Add "name" argument to dbus request APIs to help in debugging power
  problems.

[ Ubuntu daily release ]
* Automatic snapshot from revision 77

Show diffs side-by-side

added added

removed removed

Lines of Context:
cli/powerd-cli.c
45
45
const char *powerd_cli_bus_name;
46
46
 
47
47
struct PublicSysRequest {
48
 
    const gchar *owner;
 
48
    const char *name;
 
49
    const char *owner;
49
50
    int state;
50
51
};
51
52
 
52
53
struct PublicDispRequest {
53
 
    const gchar *owner;
 
54
    const char *name;
 
55
    const char *owner;
54
56
    enum powerd_display_state state;
55
57
    guint32 flags;
56
58
};
93
95
}
94
96
 
95
97
gboolean
96
 
requestSysState(int state,
 
98
requestSysState(const char *name, int state,
97
99
        powerd_cookie_t *cookie)
98
100
{
99
101
    GVariant *ret = NULL;
108
110
 
109
111
    ret = g_dbus_proxy_call_sync(powerd_proxy,
110
112
            "requestSysState",
111
 
            g_variant_new("(i)", state),
 
113
            g_variant_new("(si)", name, state),
112
114
            G_DBUS_CALL_FLAGS_NONE,
113
115
            -1,
114
116
            NULL,
133
135
}
134
136
 
135
137
static gboolean
136
 
requestDisplayState(struct PublicDispRequest pdr,
 
138
requestDisplayState(struct PublicDispRequest pdr, const char *name,
137
139
        powerd_cookie_t *cookie)
138
140
{
139
141
    GVariant *ret = NULL;
148
150
 
149
151
    ret = g_dbus_proxy_call_sync(powerd_proxy,
150
152
            "requestDisplayState",
151
 
            g_variant_new("(iu)", pdr.state, pdr.flags),
 
153
            g_variant_new("(siu)", name, pdr.state, pdr.flags),
152
154
            G_DBUS_CALL_FLAGS_NONE,
153
155
            -1,
154
156
            NULL,
193
195
            NULL,
194
196
            &error);
195
197
    if (!ret) {
196
 
        cli_warn("requestDisplayState failed: %s", error->message);
 
198
        cli_warn("updateDisplayState failed: %s", error->message);
197
199
        g_error_free(error);
198
200
        return FALSE;
199
201
    }
223
225
        g_error_free(error);
224
226
    }
225
227
    else {
226
 
        g_variant_get(ret, "(a(si))", &iter);
 
228
        g_variant_get(ret, "(a(ssi))", &iter);
227
229
        while ((item = g_variant_iter_next_value (iter))) {
228
 
            g_variant_get_child (item, 0, "s", &psr.owner);
229
 
            g_variant_get_child (item, 1, "i", &psr.state);
 
230
            g_variant_get_child (item, 0, "s", &psr.name);
 
231
            g_variant_get_child (item, 1, "s", &psr.owner);
 
232
            g_variant_get_child (item, 2, "i", &psr.state);
230
233
            g_array_append_val(retarray, psr);
231
234
            g_variant_unref(item);
232
235
        }
246
249
    } else {
247
250
        for (i = 0; i < requests->len; i++) {
248
251
            psr = &g_array_index(requests, struct PublicSysRequest, i);
249
 
            printf("  Owner: %s, State: %d\n", psr->owner, psr->state);
 
252
            printf("  Name: %s, Owner: %s, State: %d\n", psr->name,
 
253
                   psr->owner, psr->state);
250
254
        }
251
255
    }
252
256
}
272
276
        g_error_free(error);
273
277
    }
274
278
    else {
275
 
        g_variant_get(ret, "(a(siu))", &iter);
 
279
        g_variant_get(ret, "(a(ssiu))", &iter);
276
280
        while ((item = g_variant_iter_next_value (iter))) {
277
 
            g_variant_get_child(item, 0, "s", &pdr.owner);
278
 
            g_variant_get_child(item, 1, "i", &pdr.state);
279
 
            g_variant_get_child(item, 2, "u", &pdr.flags);
 
281
            g_variant_get_child(item, 0, "s", &pdr.name);
 
282
            g_variant_get_child(item, 1, "s", &pdr.owner);
 
283
            g_variant_get_child(item, 2, "i", &pdr.state);
 
284
            g_variant_get_child(item, 3, "u", &pdr.flags);
280
285
            g_array_append_val(retarray, pdr);
281
286
            g_variant_unref(item);
282
287
        }
296
301
    } else {
297
302
        for (i = 0; i < requests->len; i++) {
298
303
            pdr = &g_array_index(requests, struct PublicDispRequest, i);
299
 
            printf("  Owner: %s, State: %d, Flags: %#08x\n",
300
 
                   pdr->owner, pdr->state, pdr->flags);
 
304
            printf("  Name: %s, Owner: %s, State: %d, Flags: %#08x\n",
 
305
                   pdr->name, pdr->owner, pdr->state, pdr->flags);
301
306
        }
302
307
    }
303
308
}
436
441
    main_loop = g_main_loop_new (NULL, FALSE);
437
442
 
438
443
    // Hold active state request as long we're running tests
439
 
    requestSysState(POWERD_SYS_STATE_ACTIVE, &main_cookie);
 
444
    requestSysState("main-req", POWERD_SYS_STATE_ACTIVE, &main_cookie);
440
445
 
441
446
    ret = g_spawn_async_with_pipes(NULL, argv, NULL,
442
447
        G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD,
466
471
    silence_errors(TRUE);
467
472
 
468
473
    // Hold active state request as long we're running tests
469
 
    requestSysState(POWERD_SYS_STATE_ACTIVE, &main_cookie);
 
474
    requestSysState("main-req", POWERD_SYS_STATE_ACTIVE, &main_cookie);
470
475
 
471
 
    for (i = 0; i < TEST_NUM_SYS_REQUESTS; i++)
472
 
        do_test(requestSysState(POWERD_SYS_STATE_ACTIVE, &cookies[i]) == TRUE);
 
476
    for (i = 0; i < TEST_NUM_SYS_REQUESTS; i++) {
 
477
        char name[16];
 
478
        snprintf(name, sizeof(name), "test-cookie-%d", i);
 
479
        do_test(requestSysState(name, POWERD_SYS_STATE_ACTIVE, &cookies[i]) == TRUE);
 
480
    }
473
481
 
474
482
    // Make sure we have at least NUM_REQUESTS + 1
475
483
    requests = listSysRequests();
501
509
    g_array_free(requests, TRUE);
502
510
 
503
511
    //cannot request the suspend state, this will fail
504
 
    do_test(requestSysState(POWERD_SYS_STATE_SUSPEND, &cookie) == FALSE);
 
512
    do_test(requestSysState("test-cookie", POWERD_SYS_STATE_SUSPEND, &cookie) == FALSE);
505
513
    //invalid values
506
 
    do_test(requestSysState(-1, &cookie) == FALSE);
507
 
    do_test(requestSysState(POWERD_NUM_POWER_STATES, &cookie) == FALSE);
508
 
    do_test(requestSysState(POWERD_NUM_POWER_STATES+1, &cookie) == FALSE);
 
514
    do_test(requestSysState("test-cookie", -1, &cookie) == FALSE);
 
515
    do_test(requestSysState("test-cookie", POWERD_NUM_POWER_STATES, &cookie) == FALSE);
 
516
    do_test(requestSysState("test-cookie", POWERD_NUM_POWER_STATES+1, &cookie) == FALSE);
509
517
 
510
518
    //cleanup
511
519
    do_test(clearSysState(main_cookie) == TRUE);
527
535
    silence_errors(TRUE);
528
536
 
529
537
    // Hold active state request as long we're running tests
530
 
    requestSysState(POWERD_SYS_STATE_ACTIVE, &main_cookie);
 
538
    requestSysState("main-req", POWERD_SYS_STATE_ACTIVE, &main_cookie);
531
539
 
532
540
    for (i = 0; i < TEST_NUM_DISP_REQUESTS; i++) {
 
541
        char name[16];
 
542
        snprintf(name, sizeof(name), "disp-test-%d", i);
533
543
        pdr.state = state++;
534
544
        pdr.flags = 0;
535
545
        if (bright) {
536
546
            pdr.flags |= POWERD_DISPLAY_FLAG_BRIGHT;
537
547
        }
538
 
        do_test(requestDisplayState(pdr, &cookies[i]) == TRUE);
 
548
        do_test(requestDisplayState(pdr, name, &cookies[i]) == TRUE);
539
549
        if (state >= POWERD_NUM_DISPLAY_STATES) {
540
550
            state = 0;
541
551
        }
567
577
 
568
578
    //invalid values
569
579
    pdr.state = -1;
570
 
    do_test(requestDisplayState(pdr, &cookie) == FALSE);
 
580
    do_test(requestDisplayState(pdr, "disp-test", &cookie) == FALSE);
571
581
 
572
582
    pdr.state = POWERD_NUM_DISPLAY_STATES;
573
 
    do_test(requestDisplayState(pdr, &cookie) == FALSE);
 
583
    do_test(requestDisplayState(pdr, "disp-test", &cookie) == FALSE);
574
584
 
575
585
    pdr.state = POWERD_DISPLAY_STATE_ON;
576
586
    pdr.flags = 0xdeadbeef;
577
 
    do_test(requestDisplayState(pdr, &cookie) == FALSE);
 
587
    do_test(requestDisplayState(pdr, "disp-test", &cookie) == FALSE);
578
588
 
579
589
    // updateDisplayState tests
580
590
    pdr.state = POWERD_DISPLAY_STATE_ON;
581
591
    pdr.flags = 0;
582
 
    do_test(requestDisplayState(pdr, &cookie) == TRUE);
 
592
    do_test(requestDisplayState(pdr, "disp-test", &cookie) == TRUE);
583
593
 
584
594
    // update with same state should be okay
585
595
    do_test(updateDisplayState(pdr, cookie) == TRUE);
798
808
        g_array_free(requests, TRUE);
799
809
    }
800
810
    else if (!strcmp(argv[1],"active-nc")) {
801
 
        requestSysState(POWERD_SYS_STATE_ACTIVE,&cookie);
 
811
        requestSysState("active-nc", POWERD_SYS_STATE_ACTIVE,&cookie);
802
812
        printf("Power State requested, cookie is %s\n", cookie);
803
813
        return 0;
804
814
    }
805
815
    else if (!strcmp(argv[1],"active")) {
806
 
        requestSysState(POWERD_SYS_STATE_ACTIVE,&cookie);
 
816
        requestSysState("active", POWERD_SYS_STATE_ACTIVE,&cookie);
807
817
        printf("Power State requested, cookie is %s.\nPress ctrl-c to exit.\n",
808
818
            cookie);
809
819
        pause();  /* wait for SIGINT */
820
830
            usage(argv[0]);
821
831
            return -1;
822
832
        }
823
 
        requestDisplayState(pdr,&cookie);
 
833
        requestDisplayState(pdr, "disp-test", &cookie);
824
834
        printf("Display State requested, cookie is %s.\nPress ctrl-c to exit.\n",
825
835
            cookie);
826
836
        pause();  /* wait for SIGINT */
885
895
        // This printf is read by the parent
886
896
        printf("DBUSNAME: %s\n", bus_name);
887
897
        // Grab some requests so we can see that they get cleared later
888
 
        requestSysState(POWERD_SYS_STATE_ACTIVE,&cookie);
889
 
        requestSysState(POWERD_SYS_STATE_ACTIVE,&cookie);
890
 
        requestSysState(POWERD_SYS_STATE_ACTIVE,&cookie);
 
898
        requestSysState("dbusnametest1", POWERD_SYS_STATE_ACTIVE,&cookie);
 
899
        requestSysState("dbusnametest2", POWERD_SYS_STATE_ACTIVE,&cookie);
 
900
        requestSysState("dbusnametest3", POWERD_SYS_STATE_ACTIVE,&cookie);
891
901
        pdr.state = POWERD_DISPLAY_STATE_DONT_CARE;
892
902
        pdr.flags = 0;
893
 
        requestDisplayState(pdr, &cookie);
894
 
        requestDisplayState(pdr, &cookie);
895
 
        requestDisplayState(pdr, &cookie);
 
903
        requestDisplayState(pdr, "dbusnametest1", &cookie);
 
904
        requestDisplayState(pdr, "dbusnametest2", &cookie);
 
905
        requestDisplayState(pdr, "dbusnametest3", &cookie);
896
906
        g_object_unref(bus);
897
907
        // Exit here without cleanup
898
908
        return 0;