← Back to branch summary

~mm-yuhu/gearmand/server-funcs

« back to all changes in this revision

Viewing changes to libgearman/behavior.c

  • Committer: Brian Aker
  • Date: 2008-09-15 18:17:17 UTC
  • Revision ID: brian@gir.lan-20080915181717-mb6tl0n8kr8q76gx
Import from HG

Show diffs side-by-side

added added

removed removed

Lines of Context:
libgearman/behavior.c
 
1
#include "common.h" 
 
2
#include <sys/types.h>
 
3
#include <sys/socket.h>
 
4
#include <netinet/tcp.h>
 
5
 
 
6
/* 
 
7
  This function is used to modify the behabior of running client.
 
8
 
 
9
  We quit all connections so we can reset the sockets.
 
10
*/
 
11
 
 
12
static void set_behavior_flag(gearman_st *ptr, gearman_flags temp_flag, uint64_t data)
 
13
{
 
14
  if (data)
 
15
    ptr->flags|= temp_flag;
 
16
  else
 
17
    ptr->flags&= ~temp_flag;
 
18
}
 
19
 
 
20
gearman_return gearman_behavior_set(gearman_st *ptr, 
 
21
                                    gearman_behavior flag, 
 
22
                                    uint64_t data)
 
23
{
 
24
  switch (flag)
 
25
  {
 
26
  case GEARMAN_BEHAVIOR_SUPPORT_CAS:
 
27
    set_behavior_flag(ptr, GEAR_SUPPORT_CAS, data);
 
28
    break;
 
29
  case GEARMAN_BEHAVIOR_NO_BLOCK:
 
30
    set_behavior_flag(ptr, GEAR_NO_BLOCK, data);
 
31
    gearman_quit(ptr);
 
32
  case GEARMAN_BEHAVIOR_BUFFER_REQUESTS:
 
33
    set_behavior_flag(ptr, GEAR_BUFFER_REQUESTS, data);
 
34
    gearman_quit(ptr);
 
35
    break;
 
36
  case GEARMAN_BEHAVIOR_TCP_NODELAY:
 
37
    set_behavior_flag(ptr, GEAR_TCP_NODELAY, data);
 
38
    gearman_quit(ptr);
 
39
    break;
 
40
  case GEARMAN_BEHAVIOR_DISTRIBUTION:
 
41
    ptr->distribution= (gearman_server_distribution)(data);
 
42
    break;
 
43
  case GEARMAN_BEHAVIOR_HASH:
 
44
    ptr->hash= (gearman_hash)(data);
 
45
    break;
 
46
  case GEARMAN_BEHAVIOR_CACHE_LOOKUPS:
 
47
    set_behavior_flag(ptr, GEAR_USE_CACHE_LOOKUPS, data);
 
48
    gearman_quit(ptr);
 
49
    break;
 
50
  case GEARMAN_BEHAVIOR_VERIFY_KEY:
 
51
    set_behavior_flag(ptr, GEAR_VERIFY_KEY, data);
 
52
    break;
 
53
  case GEARMAN_BEHAVIOR_KETAMA:
 
54
    set_behavior_flag(ptr, GEAR_USE_KETAMA, data);
 
55
    break;
 
56
  case GEARMAN_BEHAVIOR_SORT_HOSTS:
 
57
    set_behavior_flag(ptr, GEAR_USE_SORT_HOSTS, data);
 
58
    break;
 
59
  case GEARMAN_BEHAVIOR_POLL_TIMEOUT:
 
60
    ptr->poll_timeout= (int32_t)data;
 
61
    break;
 
62
  case GEARMAN_BEHAVIOR_CONNECT_TIMEOUT:
 
63
    ptr->connect_timeout= (int32_t)data;
 
64
    break;
 
65
  case GEARMAN_BEHAVIOR_RETRY_TIMEOUT:
 
66
    ptr->retry_timeout= (int32_t)data;
 
67
    break;
 
68
  case GEARMAN_BEHAVIOR_SOCKET_SEND_SIZE:
 
69
    ptr->send_size= (int32_t)data;
 
70
    gearman_quit(ptr);
 
71
    break;
 
72
  case GEARMAN_BEHAVIOR_SOCKET_RECV_SIZE:
 
73
    ptr->recv_size= (int32_t)data;
 
74
    gearman_quit(ptr);
 
75
    break;
 
76
  case GEARMAN_BEHAVIOR_USER_DATA:
 
77
    return GEARMAN_FAILURE;
 
78
  }
 
79
 
 
80
  return GEARMAN_SUCCESS;
 
81
}
 
82
 
 
83
uint64_t gearman_behavior_get(gearman_st *ptr, 
 
84
                              gearman_behavior flag)
 
85
{
 
86
  gearman_flags temp_flag= 0;
 
87
 
 
88
  switch (flag)
 
89
  {
 
90
  case GEARMAN_BEHAVIOR_SUPPORT_CAS:
 
91
    temp_flag= GEAR_SUPPORT_CAS;
 
92
    break;
 
93
  case GEARMAN_BEHAVIOR_CACHE_LOOKUPS:
 
94
    temp_flag= GEAR_USE_CACHE_LOOKUPS;
 
95
    break;
 
96
  case GEARMAN_BEHAVIOR_NO_BLOCK:
 
97
    temp_flag= GEAR_NO_BLOCK;
 
98
    break;
 
99
  case GEARMAN_BEHAVIOR_BUFFER_REQUESTS:
 
100
    temp_flag= GEAR_BUFFER_REQUESTS;
 
101
    break;
 
102
  case GEARMAN_BEHAVIOR_TCP_NODELAY:
 
103
    temp_flag= GEAR_TCP_NODELAY;
 
104
    break;
 
105
  case GEARMAN_BEHAVIOR_VERIFY_KEY:
 
106
    temp_flag= GEAR_VERIFY_KEY;
 
107
    break;
 
108
  case GEARMAN_BEHAVIOR_DISTRIBUTION:
 
109
    return ptr->distribution;
 
110
  case GEARMAN_BEHAVIOR_HASH:
 
111
    return ptr->hash;
 
112
  case GEARMAN_BEHAVIOR_KETAMA:
 
113
    temp_flag= GEAR_USE_KETAMA;
 
114
    break;
 
115
  case GEARMAN_BEHAVIOR_SORT_HOSTS:
 
116
    temp_flag= GEAR_USE_SORT_HOSTS;
 
117
    break;
 
118
  case GEARMAN_BEHAVIOR_POLL_TIMEOUT:
 
119
    {
 
120
      return (unsigned long long)ptr->poll_timeout;
 
121
    }
 
122
  case GEARMAN_BEHAVIOR_CONNECT_TIMEOUT:
 
123
    {
 
124
      return (unsigned long long)ptr->connect_timeout;
 
125
    }
 
126
  case GEARMAN_BEHAVIOR_RETRY_TIMEOUT:
 
127
    {
 
128
      return (unsigned long long)ptr->retry_timeout;
 
129
    }
 
130
  case GEARMAN_BEHAVIOR_SOCKET_SEND_SIZE:
 
131
    {
 
132
      int sock_size;
 
133
      socklen_t sock_length= sizeof(int);
 
134
 
 
135
      /* REFACTOR */
 
136
      /* We just try the first host, and if it is down we return zero */
 
137
      if ((gearman_connect(&ptr->hosts[0])) != GEARMAN_SUCCESS)
 
138
        return 0;
 
139
 
 
140
      if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET, 
 
141
                     SO_SNDBUF, &sock_size, &sock_length))
 
142
        return 0; /* Zero means error */
 
143
 
 
144
      return sock_size;
 
145
    }
 
146
  case GEARMAN_BEHAVIOR_SOCKET_RECV_SIZE:
 
147
    {
 
148
      int sock_size;
 
149
      socklen_t sock_length= sizeof(int);
 
150
 
 
151
      /* REFACTOR */
 
152
      /* We just try the first host, and if it is down we return zero */
 
153
      if ((gearman_connect(&ptr->hosts[0])) != GEARMAN_SUCCESS)
 
154
        return 0;
 
155
 
 
156
      if (getsockopt(ptr->hosts[0].fd, SOL_SOCKET, 
 
157
                     SO_RCVBUF, &sock_size, &sock_length))
 
158
        return 0; /* Zero means error */
 
159
 
 
160
      return sock_size;
 
161
    }
 
162
  case GEARMAN_BEHAVIOR_USER_DATA:
 
163
    return GEARMAN_FAILURE;
 
164
  }
 
165
 
 
166
  WATCHPOINT_ASSERT(temp_flag); /* Programming mistake if it gets this far */
 
167
  if (ptr->flags & temp_flag)
 
168
    return 1;
 
169
  else
 
170
    return 0;
 
171
 
 
172
  return GEARMAN_SUCCESS;
 
173
}