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 *hostname, const char *portname) {

    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

        return -1;

    27

    }

    28

    29

    return remote_node_init(node_info, hostname, portname);

    30

}

    31

    32

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

    33

    // open the file

    34

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

    35

    36

    if (!fh) {

    37

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

    38

        return -1;

    39

    }

    40

    41

    // read it in line-by-line

    42

    char line_buf[POOL_FILE_LINE_LENGTH], *hostname, *portname, *c;

    43

    44

    // non-ferror error indicator

    45

    int error_flag = 0;

    46

    47

    while (1) {

    48

        // read in a line

    49

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

    50

            perr("remote_pool_load: fgets");

    51

            break;

    52

        }

    53

    54

        // strip comments

    55

        c = strchr(line_buf, '#');

    56

    57

        if (c)

    58

            *c = '\0';

    59

    60

        // skip empty lines

    61

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

    62

            if (!isspace(*c))

    63

                break;

    64

    65

        if (*c == '\0')

    66

            continue;

    67

    68

        // parse

    69

        if (!parse_hostport(line_buf, &hostname, &portname)) {

    70

            error_flag = 1;

    71

            break;

    72

        }

    73

    74

        // add it to the pool

    75

        if (remote_pool_add(pool_info, hostname, portname)) {

    76

            error_flag = 1;

    77

            break;

    78

        }

    79

    }

    80

    81

    // pick up ferrors if otherwise fine

    82

    error_flag = error_flag || ferror(fh);

    83

    84

    // close the fd

    85

    fclose(fh);

    86

    87

    // error return?

    88

    if (error_flag)

    89

        return -1;

    90

    91

    return 0;

    92

}

    93

    94

struct remote_node *remote_pool_get (struct remote_pool *pool_info) {

    95

    int i;

    96

    struct remote_node *node_info = NULL;

    97

    98

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

    99

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

   100

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

   101

            node_info = &pool_info->nodes[i];

   102

        }

   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

}