Fix typos found by Debian lintian

Closes #34

benchmark/blobslap_client.cc

@@ -252,7 +252,7 @@ int main(int argc, char *argv[])
         {
           if (benchmark.verbose > 1)
           {
-            std::cerr << "Error occured while trying to add task: " << gearman_client_error(&client);
+            std::cerr << "Error occurred while trying to add task: " << gearman_client_error(&client);
           }
           continue;
         }
@@ -267,7 +267,7 @@ int main(int argc, char *argv[])
         }
 
         error= true;
-        goto exit_immediatly;
+        goto exit_immediately;
       }
     }
 
@@ -311,7 +311,7 @@ int main(int argc, char *argv[])
     gearman_client_free(&client);
   } while (count or error);
 
-exit_immediatly:
+exit_immediately:
   if (shutdown_worker)
   {
     gearman_client_do(&master_client, "shutdown", 0, 0, 0, 0, 0);

examples/reverse_worker.cc

@@ -78,7 +78,7 @@ static gearman_return_t reverse_worker(gearman_job_st *job, void *context)
 
   if (options.verbose)
   {
-    std::cout << "Recieved " << workload_size << " bytes" << std::endl;
+    std::cout << "Received " << workload_size << " bytes" << std::endl;
   }
 
   std::vector<char> result;

gearmand/gearmand.cc

@@ -158,7 +158,7 @@ int main(int argc, char *argv[])
    "Prefix used to generate a job handle string. If not provided, the default \"H:<host_name>\" is used.")
 
   ("hashtable-buckets", boost::program_options::value(&hashtable_buckets)->default_value(GEARMAND_DEFAULT_HASH_SIZE),
-   "Number of buckets in the internal job hash tables. The default of 991 works well for about three million jobs in queue. If the number of jobs in the queue at any time will exceed three million, use proportionally larger values (991 * # of jobs / 3M). For example, to accomodate 2^32 jobs, use 1733003. This will consume ~26MB of extra memory. Gearmand cannot support more than 2^32 jobs in queue at this time.")
+   "Number of buckets in the internal job hash tables. The default of 991 works well for about three million jobs in queue. If the number of jobs in the queue at any time will exceed three million, use proportionally larger values (991 * # of jobs / 3M). For example, to accommodate 2^32 jobs, use 1733003. This will consume ~26MB of extra memory. Gearmand cannot support more than 2^32 jobs in queue at this time.")
 
   ("keepalive", boost::program_options::bool_switch(&opt_keepalive)->default_value(false),
    "Enable keepalive on sockets.")
@@ -234,7 +234,7 @@ int main(int argc, char *argv[])
   boost::program_options::options_description hidden("Hidden options");
   hidden.add_options()
   ("check-args", boost::program_options::bool_switch(&opt_check_args)->default_value(false),
-   "Check command line and configuration file argments and then exit.");
+   "Check command line and configuration file arguments and then exit.");
   all.add(hidden);
 
   boost::program_options::variables_map vm;

libgearman-server/gearmand.cc

@@ -685,7 +685,7 @@ static gearmand_error_t _listen_init(gearmand_st *gearmand)
         if (waited >= bind_timeout)
         {
           freeaddrinfo(addrinfo);
-          return gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "Timeout occured when calling bind() for %s:%s", host, port->port);
+          return gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "Timeout occurred when calling bind() for %s:%s", host, port->port);
         }
 
         if (ret != EADDRINUSE)

libgearman-server/gearmand_con.cc

@@ -771,7 +771,7 @@ void gearmand_con_check_queue(gearmand_thread_st *thread)
       gearmand_error_t rc;
       if ((rc= _con_add(thread, dcon)) != GEARMAND_SUCCESS)
       {
-        gearmand_log_gerror(GEARMAN_DEFAULT_LOG_PARAM, rc, "%s:%s _con_add() has failed, please report any crashes that occur immediatly after this.",
+        gearmand_log_gerror(GEARMAN_DEFAULT_LOG_PARAM, rc, "%s:%s _con_add() has failed, please report any crashes that occur immediately after this.",
                             dcon->host,
                             dcon->port);
         gearmand_con_free(dcon);

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

@@ -388,7 +388,7 @@ static gearmand_error_t _gear_con_add(gearman_server_con_st *connection)
           continue;
 
         case SSL_ERROR_SYSCALL:
-          return gearmand_log_perror(GEARMAN_DEFAULT_LOG_PARAM, errno, "Error occured on SSL_accept()");
+          return gearmand_log_perror(GEARMAN_DEFAULT_LOG_PARAM, errno, "Error occurred on SSL_accept()");
 
         case SSL_ERROR_SSL:
         case SSL_ERROR_ZERO_RETURN:

libgearman-server/plugins/queue/drizzle/queue.cc

@@ -636,7 +636,7 @@ static gearmand_error_t _libdrizzle_done(gearman_server_st *,
 
   if (libdrizzle_failed(_libdrizzle_query(queue, &query[0], query_size)))
   {
-    return gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "Error occured from %.*s", query_size, &query[0]);
+    return gearmand_log_error(GEARMAN_DEFAULT_LOG_PARAM, "Error occurred from %.*s", query_size, &query[0]);
   }
 
   drizzle_result_free(queue->result());

libgearman-server/server.cc

@@ -854,7 +854,7 @@ gearmand_error_t gearman_server_run_command(gearman_server_con_st *server_con,
       if (job_handle_length >= GEARMAND_JOB_HANDLE_SIZE || job_handle_length < 0)
       {
         return _server_error_packet(GEARMAN_DEFAULT_LOG_PARAM, server_con, GEARMAN_ARGUMENT_TOO_LARGE,
-                                    gearman_literal_param("Error occured due to GEARMAND_JOB_HANDLE_SIZE being too small from snprintf"));
+                                    gearman_literal_param("Error occurred due to GEARMAND_JOB_HANDLE_SIZE being too small from snprintf"));
       }
 
       gearman_server_job_st *server_job= gearman_server_job_get(Server, job_handle, (size_t)job_handle_length,

libgearman/check.cc

@@ -66,7 +66,7 @@ gearman_return_t EchoCheck::success(gearman_connection_st* con)
     if (memcmp(_workload, con->_packet.value(), compared) == 0)
     {
       return gearman_universal_set_error(_universal, GEARMAN_ECHO_DATA_CORRUPTION, GEARMAN_AT,
-                                         "Truncation occured, Expected %u, received %u",
+                                         "Truncation occurred, Expected %u, received %u",
                                          uint32_t(_workload_size), uint32_t(con->_packet.data_size));
     }
 

libgearman/client.cc

@@ -154,7 +154,7 @@ static void *_client_do(gearman_client_st *client_shell, gearman_command_t comma
     // We only record the error if it is different then the one we saved.
     if (client->universal.error_code() != ret)
     {
-      gearman_error(client->universal, ret, "occured during gearman_client_run_tasks()");
+      gearman_error(client->universal, ret, "occurred during gearman_client_run_tasks()");
     }
 
     *ret_ptr= ret;
@@ -195,7 +195,7 @@ static void *_client_do(gearman_client_st *client_shell, gearman_command_t comma
   }
   else // gearman_client_run_tasks() was successful, but the task was not
   {
-    gearman_error(client->universal, do_task->impl()->error_code(), "occured during gearman_client_run_tasks()");
+    gearman_error(client->universal, do_task->impl()->error_code(), "occurred during gearman_client_run_tasks()");
 
     *ret_ptr= do_task->impl()->error_code();
     *result_size= 0;
@@ -1720,7 +1720,7 @@ gearman_return_t gearman_client_run_tasks(gearman_client_st *client_shell)
   {
     Client* client= client_shell->impl();
 
-    if (client->task_list == NULL) // We are immediatly successful if all tasks are completed
+    if (client->task_list == NULL) // We are immediately successful if all tasks are completed
     {
       return GEARMAN_SUCCESS;
     }
@@ -1745,7 +1745,7 @@ gearman_return_t gearman_client_run_tasks(gearman_client_st *client_shell)
 
 gearman_return_t gearman_client_run_block_tasks(Client* client, gearman_task_st* exit_task)
 {
-  if (client->task_list == NULL) // We are immediatly successful if all tasks are completed
+  if (client->task_list == NULL) // We are immediately successful if all tasks are completed
   {
     return GEARMAN_SUCCESS;
   }

libgearman/do.cc

@@ -97,7 +97,7 @@ void *client_do(gearman_client_st *client_shell, gearman_command_t command,
   // gearman_client_run_block_tasks failed
   if (gearman_failed(ret))
   {
-    gearman_error(client->universal, ret, "occured during gearman_client_run_tasks()");
+    gearman_error(client->universal, ret, "occurred during gearman_client_run_tasks()");
 
     *ret_ptr= ret;
     *result_size= 0;
@@ -119,7 +119,7 @@ void *client_do(gearman_client_st *client_shell, gearman_command_t command,
     }
     else // gearman_client_run_block_tasks() was successful, but the task was not
     {
-      gearman_error(client->universal, do_task->impl()->error_code(), "occured during gearman_client_run_tasks()");
+      gearman_error(client->universal, do_task->impl()->error_code(), "occurred during gearman_client_run_tasks()");
 
       *ret_ptr= do_task->impl()->error_code();
       *result_size= 0;

libgearman/worker.cc

@@ -850,7 +850,7 @@ gearman_job_st *gearman_worker_grab_job(gearman_worker_st *worker_shell,
 
                 if (worker->job()->impl()->assigned.command == GEARMAN_COMMAND_NOOP)
                 {
-                  gearman_log_debug(worker->universal, "Recieved NOOP");
+                  gearman_log_debug(worker->universal, "Received NOOP");
                 }
 
                 if (worker->job()->impl()->assigned.command == GEARMAN_COMMAND_JOB_ASSIGN or

libtest/server_container.cc

@@ -358,7 +358,7 @@ bool server_startup_st::_start_server(const bool is_socket,
   }
   catch (...)
   {
-    Error << "error occured while creating server: " << server_type;
+    Error << "error occurred while creating server: " << server_type;
     return false;
   }
 

tests/workers/v2/split.cc

@@ -64,7 +64,7 @@ gearman_return_t split_worker(gearman_job_st *job, void* /* context */)
     {
       if ((workload +x -chunk_begin) == 11 and memcmp(chunk_begin, test_literal_param("mapper_fail") == 0))
       {
-        return gearman_job_send_exception(job, test_literal_param("Error occured on purpose"));
+        return gearman_job_send_exception(job, test_literal_param("Error occurred on purpose"));
       }
 
       // NULL Chunk
@@ -82,7 +82,7 @@ gearman_return_t split_worker(gearman_job_st *job, void* /* context */)
   {
     if ((size_t(workload +workload_size) -size_t(chunk_begin) ) == 11 and not memcmp(chunk_begin, test_literal_param("mapper_fail")))
     {
-      return gearman_job_send_exception(job, test_literal_param("Error occured on purpose"));
+      return gearman_job_send_exception(job, test_literal_param("Error occurred on purpose"));
     }
 
     gearman_return_t rc= gearman_job_send_data(job, chunk_begin, size_t(workload +workload_size) -size_t(chunk_begin));

util/instance.cc

@@ -388,7 +388,7 @@ bool Instance::run()
                     if (errno)
                     {
                       std::stringstream msg;
-                      msg << "Error occured on SSL_acceptsend(" << strerror(errno) << ")";
+                      msg << "Error occurred on SSL_acceptsend(" << strerror(errno) << ")";
                       _last_error= msg.str();
                       read_size= SOCKET_ERROR;
                       break;
@@ -426,7 +426,7 @@ bool Instance::run()
             if (_last_error.empty())
             {
               _last_error.clear();
-              _last_error+= "Error occured while reading data from ";
+              _last_error+= "Error occurred while reading data from ";
               _last_error+= _host;
             }
 

util/pidfile.cc

@@ -112,7 +112,7 @@ bool Pidfile::create()
     {
       _last_errno= errno;
       std::stringstream error_stream;
-      error_stream << "Unable to remove exisiting file:" << _filename << "(" << strerror(errno) << ")";
+      error_stream << "Unable to remove existing file:" << _filename << "(" << strerror(errno) << ")";
       _error_message= error_stream.str();
 
       return false;