1

#include <string.h>

     2

#include <stdio.h>

     3

#include <ctype.h>

     4

     5

#include "remote_pool.h"

     6

#include "common.h"

     7

     8

void remote_pool_init (struct remote_pool *pool_info) {

     9

    memset(pool_info, 0, sizeof(*pool_info));

    10

}

    11

    12

int remote_pool_add (struct remote_pool *pool_info, const char *addr_spec) {

    13

    int i;

    14

    struct remote_node *node_info = NULL;

    15

    16

    // find a free remote_node entry and store its pointer in node_info

    17

    for (i = 0; i < REMOTE_POOL_MAX; i++) {

    18

        if (!pool_info->nodes[i].valid) {

    19

            node_info = &pool_info->nodes[i];

    20

            break;

    21

        }

    22

    }

    23

    24

    if (!node_info)

    25

        ERROR("remote_pool_add: pool full, consider increasing REMOTE_POOL_MAX");

    26

    27

    return remote_node_init(node_info, addr_spec);

    28

    29

error:

    30

    return -1;

    31

}

    32

    33

int remote_pool_load (struct remote_pool *pool_info, const char *filename) {

    34

    // open the file

    35

    FILE *fh = fopen(filename, "r");

    36

    37

    if (!fh) {

    38

        perr("remote_pool_load: fopen(%s)", filename);

    39

        return -1;

    40

    }

    41

    42

    // read it in line-by-line

    43

    char line_buf[POOL_FILE_LINE_LENGTH], *c;

    44

    45

    // non-ferror error indicator

    46

    int error_flag = 0;

    47

    48

    while (1) {

    49

        // read in a line

    50

        if (!fgets(line_buf, POOL_FILE_LINE_LENGTH, fh)) {

    51

            perr("remote_pool_load: fgets");

    52

            break;

    53

        }

    54

    55

        // strip comments

    56

        c = strchr(line_buf, '#');

    57

    58

        if (c)

    59

            *c = '\0';

    60

    61

        // skip empty lines

    62

        for (c = line_buf; *c != '\0'; c++)

    63

            if (!isspace(*c))

    64

                break;

    65

    66

        if (*c == '\0')

    67

            continue;

    68

    69

        // add it to the pool

    70

        if (remote_pool_add(pool_info, line_buf)) {

    71

            error_flag = 1;

    72

            break;

    73

        }

    74

    }

    75

    76

    // pick up ferrors if otherwise fine

    77

    error_flag = error_flag || ferror(fh);

    78

    79

    // close the fd

    80

    fclose(fh);

    81

    82

    // error return?

    83

    if (error_flag)

    84

        return -1;

    85

    86

    return 0;

    87

}

    88

    89

struct remote_node *remote_pool_get (struct remote_pool *pool_info) {

    90

    int i;

    91

    struct remote_node *node_info = NULL;

    92

    93

    // find a the appropriate remote_node entry and store its pointer in node_info

    94

    for (i = 0; i < REMOTE_POOL_MAX; i++) {

    95

        if (pool_info->nodes[i].valid && (node_info == NULL || pool_info->nodes[i].current_load < node_info->current_load)) {

    96

            node_info = &pool_info->nodes[i];

    97

        }

    98

    }

    99

   100

    if (node_info) {

   101

        // add one to its load, because that's probably correct, and works if we pick multiple nodes from the pool at the same time

   102

        node_info->current_load++;

   103

    }

   104

   105

    // either NULL or the right remote_info

   106

    return node_info;

   107

}

   108

   109

int remote_pool_size (struct remote_pool *pool_info) {

   110

    int i, size = 0;

   111

   112

    for (i = 0; i < REMOTE_POOL_MAX; i++) {

   113

        if (pool_info->nodes[i].valid) {

   114

            size++;

   115

        }

   116

    }

   117

   118

    return size;

   119

}