← Back to branch summary

~ubuntu-branches/ubuntu/precise/slurm-llnl/precise

« back to all changes in this revision

Viewing changes to contribs/perlapi/libslurmdb/perl/Slurmdb.xs

  • Committer: Bazaar Package Importer
  • Author(s): Gennaro Oliva
  • Date: 2011-04-08 11:21:17 UTC
  • mfrom: (3.3.16 sid)
  • Revision ID: james.westby@ubuntu.com-20110408112117-nfnyq9dtm55hqoaw
Tags: 2.2.4-1
http://bugs.debian.org/575822
* New upstream releases 
* Cleaning spare file and directories, not belonging to the sources
  generated by the building process and not removed by distclean.
  Added debian/clean with spare files and rm -rf inside debian/rules
  for directories.
* Added new packages libslurm-perl, libslurmdb-perl, slurm-llnl-torque
  (Closes: #575822) thanks to Julien Blache

Show diffs side-by-side

added added

removed removed

Lines of Context:
contribs/perlapi/libslurmdb/perl/Slurmdb.xs
 
1
#include "EXTERN.h"
 
2
#include "perl.h"
 
3
#include "XSUB.h"
 
4
 
 
5
#include "ppport.h"
 
6
 
 
7
#include <slurm/slurm.h>
 
8
#include <slurm/slurmdb.h>
 
9
#include "slurmdb-perl.h"
 
10
 
 
11
#include "const-c.inc"
 
12
 
 
13
extern void *slurm_xmalloc(size_t, const char *, int, const char *);
 
14
extern void slurmdb_destroy_association_cond(void *object);
 
15
extern void slurmdb_destroy_cluster_cond(void *object);
 
16
extern void slurmdb_destroy_job_cond(void *object);
 
17
extern void slurmdb_destroy_user_cond(void *object);
 
18
 
 
19
 
 
20
MODULE = Slurmdb        PACKAGE = Slurmdb       PREFIX=slurmdb_
 
21
 
 
22
INCLUDE: const-xs.inc
 
23
PROTOTYPES: ENABLE
 
24
 
 
25
void*
 
26
slurmdb_connection_get()
 
27
 
 
28
int
 
29
slurmdb_connection_close(db_conn)
 
30
        void* db_conn
 
31
 
 
32
SV*
 
33
slurmdb_clusters_get(db_conn, conditions)
 
34
        void* db_conn
 
35
        HV*   conditions
 
36
    INIT:
 
37
        AV*   results;
 
38
        HV*   rh;
 
39
        List  list = NULL;
 
40
        ListIterator itr;
 
41
        slurmdb_cluster_cond_t *cluster_cond = (slurmdb_cluster_cond_t*)
 
42
                slurm_xmalloc(sizeof(slurmdb_cluster_cond_t), __FILE__,
 
43
                __LINE__, "slurmdb_clusters_get");
 
44
        slurmdb_cluster_rec_t *rec = NULL;
 
45
 
 
46
        if (hv_to_cluster_cond(conditions, cluster_cond) < 0) {
 
47
                XSRETURN_UNDEF;
 
48
        }
 
49
        results = (AV*)sv_2mortal((SV*)newAV());
 
50
    CODE:
 
51
        list = slurmdb_clusters_get(db_conn, cluster_cond);
 
52
        if (list) {
 
53
            itr = slurm_list_iterator_create(list);
 
54
 
 
55
            while ((rec = slurm_list_next(itr))) {
 
56
                rh = (HV *)sv_2mortal((SV*)newHV());
 
57
                if (cluster_rec_to_hv(rec, rh) < 0) {
 
58
                    XSRETURN_UNDEF;
 
59
                }
 
60
                av_push(results, newRV((SV*)rh));
 
61
            }
 
62
            slurm_list_destroy(list);
 
63
        }
 
64
        RETVAL = newRV((SV*)results);
 
65
        slurmdb_destroy_cluster_cond(cluster_cond);
 
66
    OUTPUT:
 
67
        RETVAL
 
68
 
 
69
SV*
 
70
slurmdb_report_cluster_account_by_user(db_conn, assoc_condition)
 
71
        void* db_conn
 
72
        HV*   assoc_condition
 
73
    INIT:
 
74
        AV*   results;
 
75
        List  list = NULL;
 
76
        slurmdb_association_cond_t *assoc_cond = (slurmdb_association_cond_t*)
 
77
                slurm_xmalloc(sizeof(slurmdb_association_cond_t), __FILE__,
 
78
                __LINE__, "slurmdb_report_cluster_account_by_user");
 
79
 
 
80
        if (hv_to_assoc_cond(assoc_condition, assoc_cond) < 0) {
 
81
                XSRETURN_UNDEF;
 
82
        }
 
83
        results = (AV*)sv_2mortal((SV*)newAV());
 
84
    CODE:
 
85
        list = slurmdb_report_cluster_account_by_user(db_conn, assoc_cond);
 
86
        if (list) {
 
87
            if (report_cluster_rec_list_to_av(list, results) < 0) {
 
88
                XSRETURN_UNDEF;
 
89
            }
 
90
            slurm_list_destroy(list);
 
91
        }
 
92
        RETVAL = newRV((SV*)results);
 
93
        slurmdb_destroy_association_cond(assoc_cond);
 
94
    OUTPUT:
 
95
        RETVAL
 
96
 
 
97
SV*
 
98
slurmdb_report_cluster_user_by_account(db_conn, assoc_condition)
 
99
        void* db_conn
 
100
        HV*   assoc_condition
 
101
    INIT:
 
102
        AV*   results;
 
103
        List  list = NULL;
 
104
        slurmdb_association_cond_t *assoc_cond = (slurmdb_association_cond_t*)
 
105
                slurm_xmalloc(sizeof(slurmdb_association_cond_t), __FILE__,
 
106
                __LINE__, "slurmdb_report_cluster_user_by_account");
 
107
 
 
108
        if (hv_to_assoc_cond(assoc_condition, assoc_cond) < 0) {
 
109
                XSRETURN_UNDEF;
 
110
        }
 
111
        results = (AV*)sv_2mortal((SV*)newAV());
 
112
    CODE:
 
113
        list = slurmdb_report_cluster_user_by_account(db_conn, assoc_cond);
 
114
        if (list) {
 
115
            if (report_cluster_rec_list_to_av(list, results) < 0) {
 
116
                XSRETURN_UNDEF;
 
117
            }
 
118
            slurm_list_destroy(list);
 
119
        }
 
120
        RETVAL = newRV((SV*)results);
 
121
        slurmdb_destroy_association_cond(assoc_cond);
 
122
    OUTPUT:
 
123
        RETVAL
 
124
 
 
125
SV*
 
126
slurmdb_report_job_sizes_grouped_by_top_account(db_conn, job_condition, grouping_array, flat_view)
 
127
        void* db_conn
 
128
        HV*   job_condition
 
129
        AV*   grouping_array
 
130
        bool  flat_view
 
131
    INIT:
 
132
        AV*   results;
 
133
        List  list = NULL;
 
134
        List grouping_list = slurm_list_create(NULL);
 
135
        slurmdb_job_cond_t *job_cond = (slurmdb_job_cond_t*)
 
136
                slurm_xmalloc(sizeof(slurmdb_job_cond_t), __FILE__,
 
137
                __LINE__, "slurmdb_report_job_sizes_grouped_by_top_account");
 
138
        if (hv_to_job_cond(job_condition, job_cond) < 0) {
 
139
                XSRETURN_UNDEF;
 
140
        }
 
141
        if (av_to_cluster_grouping_list(grouping_array, grouping_list) < 0) {
 
142
                XSRETURN_UNDEF;
 
143
        }
 
144
        results = (AV*)sv_2mortal((SV*)newAV());
 
145
    CODE:
 
146
        list = slurmdb_report_job_sizes_grouped_by_top_account(db_conn,
 
147
                job_cond, grouping_list, flat_view);
 
148
        if (list) {
 
149
            if (cluster_grouping_list_to_av(list, results) < 0) {
 
150
                XSRETURN_UNDEF;
 
151
            }
 
152
            slurm_list_destroy(list);
 
153
        }
 
154
        RETVAL = newRV((SV*)results);
 
155
        slurmdb_destroy_job_cond(job_cond);
 
156
        slurm_list_destroy(grouping_list);
 
157
    OUTPUT:
 
158
        RETVAL
 
159
 
 
160
SV*
 
161
slurmdb_report_user_top_usage(db_conn, user_condition, group_accounts)
 
162
        void* db_conn
 
163
        HV*   user_condition
 
164
        bool  group_accounts
 
165
    INIT:
 
166
        AV*   results;
 
167
        List  list = NULL;
 
168
        slurmdb_user_cond_t* user_cond = (slurmdb_user_cond_t*)
 
169
                slurm_xmalloc(sizeof(slurmdb_user_cond_t), __FILE__,
 
170
                __LINE__, "slurmdb_report_user_top_usage");
 
171
        user_cond->assoc_cond = (slurmdb_association_cond_t*)
 
172
                slurm_xmalloc(sizeof(slurmdb_association_cond_t), __FILE__,
 
173
                __LINE__, "slurmdb_report_user_top_usage");
 
174
        if (hv_to_user_cond(user_condition, user_cond) < 0) {
 
175
                XSRETURN_UNDEF;
 
176
        }
 
177
        results = (AV*)sv_2mortal((SV*)newAV());
 
178
    CODE:
 
179
        list = slurmdb_report_user_top_usage(db_conn, user_cond,
 
180
                                             group_accounts);
 
181
        if (list) {
 
182
            if (report_cluster_rec_list_to_av(list, results) < 0) {
 
183
                XSRETURN_UNDEF;
 
184
            }
 
185
            slurm_list_destroy(list);
 
186
        }
 
187
        RETVAL = newRV((SV*)results);
 
188
        slurmdb_destroy_user_cond(user_cond);
 
189
    OUTPUT:
 
190
        RETVAL