Fix rename issue.

libgearman-server/constants.h

@@ -83,7 +83,7 @@
 #define GEARMAND_SEND_BUFFER_SIZE 8192
 #define GEARMAND_SERVER_CON_ID_SIZE 128
 #define GEARMAND_TEXT_RESPONSE_SIZE 8192
-#define GEARMAND_MAGIC_MEMORY (void*)(0x000001)
+#define GEARMAN_MAGIC_MEMORY (void*)(0x000001)
 
 /** @} */
 

libgearman-server/io.cc

@@ -634,7 +634,7 @@ gearmand_error_t gearman_io_recv(gearman_server_con_st *con, bool recv_data)
 
     connection->recv_packet= packet;
     // The options being passed in are just defaults.
-    connection->recv_packet->reset(GEARMAND_MAGIC_TEXT, GEARMAN_COMMAND_TEXT);
+    connection->recv_packet->reset(GEARMAN_MAGIC_TEXT, GEARMAN_COMMAND_TEXT);
 
     connection->recv_state= gearmand_io_st::GEARMAND_CON_RECV_UNIVERSAL_READ;
 

libgearman-server/job.cc

@@ -354,7 +354,7 @@ gearmand_error_t gearman_server_job_queue(gearman_server_job_st *job)
       for (client= job->client_list; client != NULL; client= client->job_next)
       {
         gearmand_error_t ret= gearman_server_io_packet_add(client->con, false,
-                                                           GEARMAND_MAGIC_RESPONSE,
+                                                           GEARMAN_MAGIC_RESPONSE,
                                                            GEARMAN_COMMAND_WORK_FAIL,
                                                            job->job_handle,
                                                            (size_t)strlen(job->job_handle),
@@ -401,7 +401,7 @@ gearmand_error_t gearman_server_job_queue(gearman_server_job_st *job)
       if (worker->con->is_sleeping && ! (worker->con->is_noop_sent))
       {
         gearmand_error_t ret= gearman_server_io_packet_add(worker->con, false,
-                                                           GEARMAND_MAGIC_RESPONSE,
+                                                           GEARMAN_MAGIC_RESPONSE,
                                                            GEARMAN_COMMAND_NOOP, NULL);
         if (gearmand_failed(ret))
         {

libgearman-server/packet.cc

@@ -299,7 +299,7 @@ inline static gearmand_error_t packet_create_arg(gearmand_packet_st *packet,
     return GEARMAND_SUCCESS;
   }
 
-  if (packet->args_size == 0 and packet->magic != GEARMAND_MAGIC_TEXT)
+  if (packet->args_size == 0 and packet->magic != GEARMAN_MAGIC_TEXT)
   {
     packet->args_size= GEARMAND_PACKET_HEADER_SIZE;
   }
@@ -333,7 +333,7 @@ inline static gearmand_error_t packet_create_arg(gearmand_packet_st *packet,
   packet->argc++;
 
   size_t offset;
-  if (packet->magic == GEARMAND_MAGIC_TEXT)
+  if (packet->magic == GEARMAN_MAGIC_TEXT)
   {
     offset= 0;
   }
@@ -398,7 +398,7 @@ void gearmand_packet_free(gearmand_packet_st *packet)
 
 gearmand_error_t gearmand_packet_pack_header(gearmand_packet_st *packet)
 {
-  if (packet->magic == GEARMAND_MAGIC_TEXT)
+  if (packet->magic == GEARMAN_MAGIC_TEXT)
   {
     packet->options.complete= true;
     return GEARMAND_SUCCESS;
@@ -412,14 +412,14 @@ gearmand_error_t gearmand_packet_pack_header(gearmand_packet_st *packet)
 
   switch (packet->magic)
   {
-  case GEARMAND_MAGIC_TEXT:
+  case GEARMAN_MAGIC_TEXT:
     break;
 
-  case GEARMAND_MAGIC_REQUEST:
+  case GEARMAN_MAGIC_REQUEST:
     memcpy(packet->args, "\0REQ", 4);
     break;
 
-  case GEARMAND_MAGIC_RESPONSE:
+  case GEARMAN_MAGIC_RESPONSE:
     memcpy(packet->args, "\0RES", 4);
     break;
 

libgearman-server/plugins/protocol/gear/protocol.cc

@@ -59,11 +59,11 @@ static gearmand_error_t gearmand_packet_unpack_header(gearmand_packet_st *packet
 
   if (memcmp(packet->args, "\0REQ", 4) == 0)
   {
-    packet->magic= GEARMAND_MAGIC_REQUEST;
+    packet->magic= GEARMAN_MAGIC_REQUEST;
   }
   else if (memcmp(packet->args, "\0RES", 4) == 0)
   {
-    packet->magic= GEARMAND_MAGIC_RESPONSE;
+    packet->magic= GEARMAN_MAGIC_RESPONSE;
   }
   else
   {
@@ -123,7 +123,7 @@ public:
           return 0;
         }
 
-        packet->magic= GEARMAND_MAGIC_TEXT;
+        packet->magic= GEARMAN_MAGIC_TEXT;
         packet->command= GEARMAN_COMMAND_TEXT;
 
         used_size= size_t(ptr - ((uint8_t *)data)) +1;

libgearman-server/plugins/protocol/http/protocol.cc

@@ -454,7 +454,7 @@ public:
     }
 
     /* Request and all headers complete, build a packet based on HTTP request. */
-    packet->magic= GEARMAND_MAGIC_REQUEST;
+    packet->magic= GEARMAN_MAGIC_REQUEST;
 
     if (response() != gearmand::protocol::httpd::HTTP_OK)
     {

libgearman-server/server.cc

@@ -55,6 +55,7 @@
 
 #include "libgearman-1.0/return.h"
 #include "libgearman-1.0/strerror.h"
+#include "libgearman/magic.h"
 
 /*
  * Private declarations
@@ -76,7 +77,7 @@ static gearmand_error_t _server_error_packet(gearman_server_con_st *server_con,
   const char* error_code_string= gearman_strerror(error_code);
   error_code_string+= 8;
 
-  return gearman_server_io_packet_add(server_con, false, GEARMAND_MAGIC_RESPONSE,
+  return gearman_server_io_packet_add(server_con, false, GEARMAN_MAGIC_RESPONSE,
                                       GEARMAN_COMMAND_ERROR, error_code_string,
                                       (size_t)(strlen(error_code_string) + 1),
                                       error_string,
@@ -102,7 +103,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
   gearmand_error_t ret;
   gearman_server_client_st *server_client= NULL;
 
-  if (packet->magic == GEARMAND_MAGIC_RESPONSE)
+  if (packet->magic == GEARMAN_MAGIC_RESPONSE)
   {
     return _server_error_packet(server_con, GEARMAN_INVALID_MAGIC, "Request magic expected");
   }
@@ -118,7 +119,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
   /* Client/worker requests. */
   case GEARMAN_COMMAND_ECHO_REQ:
     /* Reuse the data buffer and just shove the data back. */
-    ret= gearman_server_io_packet_add(server_con, true, GEARMAND_MAGIC_RESPONSE,
+    ret= gearman_server_io_packet_add(server_con, true, GEARMAN_MAGIC_RESPONSE,
                                       GEARMAN_COMMAND_ECHO_RES, packet->data,
                                       packet->data_size, NULL);
     if (gearmand_failed(ret))
@@ -178,7 +179,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
       }
 
       /* Queue the job created packet. */
-      ret= gearman_server_io_packet_add(server_con, false, GEARMAND_MAGIC_RESPONSE,
+      ret= gearman_server_io_packet_add(server_con, false, GEARMAN_MAGIC_RESPONSE,
                                         GEARMAN_COMMAND_JOB_CREATED,
                                         server_job->job_handle,
                                         (size_t)strlen(server_job->job_handle),
@@ -298,7 +299,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
       }
 
       /* Queue the job created packet. */
-      ret= gearman_server_io_packet_add(server_con, false, GEARMAND_MAGIC_RESPONSE,
+      ret= gearman_server_io_packet_add(server_con, false, GEARMAN_MAGIC_RESPONSE,
                                         GEARMAN_COMMAND_JOB_CREATED,
                                         server_job->job_handle,
                                         (size_t)strlen(server_job->job_handle),
@@ -342,7 +343,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
       if (server_job == NULL)
       {
         ret= gearman_server_io_packet_add(server_con, false,
-                                          GEARMAND_MAGIC_RESPONSE,
+                                          GEARMAN_MAGIC_RESPONSE,
                                           GEARMAN_COMMAND_STATUS_RES_UNIQUE,
                                           unique_handle, (size_t)(unique_handle_length +1), // Job Handle
                                           "0", (size_t)2, //
@@ -379,7 +380,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
         }
 
         ret= gearman_server_io_packet_add(server_con, false,
-                                          GEARMAND_MAGIC_RESPONSE,
+                                          GEARMAN_MAGIC_RESPONSE,
                                           GEARMAN_COMMAND_STATUS_RES_UNIQUE,
                                           unique_handle, (size_t)(unique_handle_length +1), // unique_handle
                                           "1", (size_t)2, // is_known
@@ -423,7 +424,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
                            int(job_handle_length), job_handle);
 
         ret= gearman_server_io_packet_add(server_con, false,
-                                          GEARMAND_MAGIC_RESPONSE,
+                                          GEARMAN_MAGIC_RESPONSE,
                                           GEARMAN_COMMAND_STATUS_RES,
                                           job_handle, (size_t)(job_handle_length +1), // Job Handle
                                           "0", (size_t)2, //
@@ -458,7 +459,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
 
 
         ret= gearman_server_io_packet_add(server_con, false,
-                                          GEARMAND_MAGIC_RESPONSE,
+                                          GEARMAN_MAGIC_RESPONSE,
                                           GEARMAN_COMMAND_STATUS_RES,
                                           job_handle, (size_t)(job_handle_length +1),
                                           "1", (size_t)2,
@@ -503,7 +504,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
                                     "Server does not recognize given option");
       }
 
-      ret= gearman_server_io_packet_add(server_con, false, GEARMAND_MAGIC_RESPONSE,
+      ret= gearman_server_io_packet_add(server_con, false, GEARMAN_MAGIC_RESPONSE,
                                         GEARMAN_COMMAND_OPTION_RES,
                                         packet->arg[0], packet->arg_size[0],
                                         NULL);
@@ -573,7 +574,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
         /* If there are jobs that could be run, queue a NOOP packet to wake the
           worker up. This could be the result of a race codition. */
         ret= gearman_server_io_packet_add(server_con, false,
-                                          GEARMAND_MAGIC_RESPONSE,
+                                          GEARMAN_MAGIC_RESPONSE,
                                           GEARMAN_COMMAND_NOOP, NULL);
         if (ret != GEARMAND_SUCCESS)
         {
@@ -597,7 +598,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
       {
         /* No jobs found, queue no job packet. */
         ret= gearman_server_io_packet_add(server_con, false,
-                                          GEARMAND_MAGIC_RESPONSE,
+                                          GEARMAN_MAGIC_RESPONSE,
                                           GEARMAN_COMMAND_NO_JOB, NULL);
       }
       else if (packet->command == GEARMAN_COMMAND_GRAB_JOB_UNIQ)
@@ -606,7 +607,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
           We found a runnable job, queue job assigned packet and take the job off the queue. 
         */
         ret= gearman_server_io_packet_add(server_con, false,
-                                          GEARMAND_MAGIC_RESPONSE,
+                                          GEARMAN_MAGIC_RESPONSE,
                                           GEARMAN_COMMAND_JOB_ASSIGN_UNIQ,
                                           server_job->job_handle, (size_t)(strlen(server_job->job_handle) + 1),
                                           server_job->function->function_name, server_job->function->function_name_size + 1,
@@ -626,7 +627,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
           We found a runnable job, queue job assigned packet and take the job off the queue. 
         */
         ret= gearman_server_io_packet_add(server_con, false,
-                                          GEARMAND_MAGIC_RESPONSE,
+                                          GEARMAN_MAGIC_RESPONSE,
                                           GEARMAN_COMMAND_JOB_ASSIGN_ALL,
                                           server_job->job_handle, (size_t)(strlen(server_job->job_handle) + 1),
                                           server_job->function->function_name, server_job->function->function_name_size + 1,
@@ -641,7 +642,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
           We found a runnable job, queue job assigned packet and take the job off the queue. 
         */
         ret= gearman_server_io_packet_add(server_con, false,
-                                          GEARMAND_MAGIC_RESPONSE,
+                                          GEARMAN_MAGIC_RESPONSE,
                                           GEARMAN_COMMAND_JOB_ASSIGN_UNIQ,
                                           server_job->job_handle, (size_t)(strlen(server_job->job_handle) +1),
                                           server_job->function->function_name, server_job->function->function_name_size +1,
@@ -657,7 +658,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
                            (unsigned long)server_job->data_size);
         /* Same, but without unique ID. */
         ret= gearman_server_io_packet_add(server_con, false,
-                                          GEARMAND_MAGIC_RESPONSE,
+                                          GEARMAN_MAGIC_RESPONSE,
                                           GEARMAN_COMMAND_JOB_ASSIGN,
                                           server_job->job_handle, (size_t)(strlen(server_job->job_handle) + 1),
                                           server_job->function->function_name, server_job->function->function_name_size + 1,
@@ -743,7 +744,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
            server_client= server_client->job_next)
       {
         ret= gearman_server_io_packet_add(server_client->con, false,
-                                          GEARMAND_MAGIC_RESPONSE,
+                                          GEARMAN_MAGIC_RESPONSE,
                                           GEARMAN_COMMAND_WORK_STATUS,
                                           packet->arg[0], packet->arg_size[0],
                                           packet->arg[1], packet->arg_size[1],
@@ -848,7 +849,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
            server_client= server_client->job_next)
       {
         ret= gearman_server_io_packet_add(server_client->con, false,
-                                          GEARMAND_MAGIC_RESPONSE,
+                                          GEARMAN_MAGIC_RESPONSE,
                                           GEARMAN_COMMAND_WORK_FAIL,
                                           packet->arg[0], packet->arg_size[0],
                                           NULL);
@@ -1043,7 +1044,7 @@ _server_queue_work_data(gearman_server_job_st *server_job,
                                                        GEARMAN_MAGIC_RESPONSE, command,
                                                        packet->arg[0], packet->arg_size[0],
                                                        data, packet->data_size, NULL);
-    if (ret != GEARMAN_SUCCESS)
+    if (ret != GEARMAND_SUCCESS)
     {
       gearmand_gerror("gearman_server_io_packet_add", ret);
       return ret;

libgearman-server/struct/packet.h

@@ -38,13 +38,7 @@
 #pragma once
 
 #include <libgearman-1.0/protocol.h>
-
-enum gearman_magic_t
-{
-  GEARMAND_MAGIC_TEXT,
-  GEARMAND_MAGIC_REQUEST,
-  GEARMAND_MAGIC_RESPONSE
-};
+#include "libgearman/magic.h"
 
 /**
  * @ingroup gearman_packet
@@ -74,7 +68,7 @@ struct gearmand_packet_st
   char args_buffer[GEARMAND_ARGS_BUFFER_SIZE];
 
   gearmand_packet_st():
-    magic(GEARMAND_MAGIC_TEXT),
+    magic(GEARMAN_MAGIC_TEXT),
     command(GEARMAN_COMMAND_TEXT),
     argc(0),
     args_size(0),

libgearman-server/text.cc

@@ -363,7 +363,7 @@ gearmand_error_t server_run_text(gearman_server_con_st *server_con,
     return gearmand_gerror("calling gearman_server_packet_create()", GEARMAND_MEMORY_ALLOCATION_FAILURE);
   }
 
-  server_packet->packet.reset(GEARMAND_MAGIC_TEXT, GEARMAN_COMMAND_TEXT);
+  server_packet->packet.reset(GEARMAN_MAGIC_TEXT, GEARMAN_COMMAND_TEXT);
 
   server_packet->packet.options.complete= true;
   server_packet->packet.options.free_data= true;

libgearman/include.am

@@ -15,6 +15,7 @@ nobase_include_HEADERS+= libgearman/gearman.h
 noinst_HEADERS+= libgearman/client.hpp
 noinst_HEADERS+= libgearman/worker.hpp
 
+noinst_HEADERS+= libgearman/magic.h
 noinst_HEADERS+= libgearman/client.h
 noinst_HEADERS+= libgearman/check.h
 noinst_HEADERS+= libgearman/interface/client.hpp