style: fixed coding style issues found by ngx-releng.

agentzh · agentzh · commit 4b7ff9bdf669 · 2018-01-15T14:17:02.000-08:00
diff --git a/src/ngx_http_redis2_handler.c b/src/ngx_http_redis2_handler.c
@@ -44,14 +44,14 @@ ngx_http_redis2_handler(ngx_http_request_t *r)
         /* variables used in the redis2_pass directive */
 
         if (ngx_http_complex_value(r, rlcf->complex_target, &target)
-                != NGX_OK)
+            != NGX_OK)
         {
             return NGX_ERROR;
         }
 
         if (target.len == 0) {
             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
-                    "handler: empty \"redis2_pass\" target");
+                          "handler: empty \"redis2_pass\" target");
             return NGX_HTTP_INTERNAL_SERVER_ERROR;
         }
 
@@ -63,7 +63,7 @@ ngx_http_redis2_handler(ngx_http_request_t *r)
 
         if (rlcf->upstream.upstream == NULL) {
             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
-                   "redis2: upstream \"%V\" not found", &target);
+                          "redis2: upstream \"%V\" not found", &target);
 
             return NGX_HTTP_INTERNAL_SERVER_ERROR;
         }
@@ -131,20 +131,20 @@ ngx_http_redis2_create_request(ngx_http_request_t *r)
     } else if (rlcf->literal_query.len == 0) {
         if (rlcf->complex_query == NULL) {
             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
-                    "no redis2 query specified or the query is empty");
+                          "no redis2 query specified or the query is empty");
 
             return NGX_ERROR;
         }
 
         if (ngx_http_complex_value(r, rlcf->complex_query, &query)
-                != NGX_OK)
+            != NGX_OK)
         {
             return NGX_ERROR;
         }
 
         if (query.len == 0) {
             ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
-                    "the redis query is empty");
+                          "the redis query is empty");
 
             return NGX_ERROR;
         }
@@ -154,22 +154,24 @@ ngx_http_redis2_create_request(ngx_http_request_t *r)
 
         } else {
             if (ngx_http_complex_value(r, rlcf->complex_query_count,
-                    &query_count) != NGX_OK)
+                                       &query_count)
+                != NGX_OK)
             {
                 return NGX_ERROR;
             }
 
             if (query_count.len == 0) {
                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
-                        "the N argument to redis2_raw_queries is empty");
+                              "the N argument to redis2_raw_queries is empty");
 
                 return NGX_ERROR;
             }
 
             n = ngx_atoi(query_count.data, query_count.len);
             if (n == NGX_ERROR || n == 0) {
                 ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
-                        "the N argument to redis2_raw_queries is invalid");
+                              "the N argument to redis2_raw_queries is "
+                              "invalid");
 
                 return NGX_ERROR;
             }
diff --git a/src/ngx_http_redis2_module.c b/src/ngx_http_redis2_module.c
@@ -211,10 +211,10 @@ ngx_http_redis2_merge_loc_conf(ngx_conf_t *cf, void *parent, void *child)
                               (size_t) ngx_pagesize);
 
     ngx_conf_merge_bitmask_value(conf->upstream.next_upstream,
-                              prev->upstream.next_upstream,
-                              (NGX_CONF_BITMASK_SET
-                               |NGX_HTTP_UPSTREAM_FT_ERROR
-                               |NGX_HTTP_UPSTREAM_FT_TIMEOUT));
+                                 prev->upstream.next_upstream,
+                                 (NGX_CONF_BITMASK_SET
+                                  |NGX_HTTP_UPSTREAM_FT_ERROR
+                                  |NGX_HTTP_UPSTREAM_FT_TIMEOUT));
 
     if (conf->upstream.next_upstream & NGX_HTTP_UPSTREAM_FT_OFF) {
         conf->upstream.next_upstream = NGX_CONF_BITMASK_SET
@@ -395,7 +395,7 @@ ngx_http_redis2_raw_queries(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
     /* compile the N argument */
 
     rlcf->complex_query_count = ngx_palloc(cf->pool,
-            sizeof(ngx_http_complex_value_t));
+                                           sizeof(ngx_http_complex_value_t));
 
     if (rlcf->complex_query_count == NULL) {
         return NGX_CONF_ERROR;
@@ -413,7 +413,7 @@ ngx_http_redis2_raw_queries(ngx_conf_t *cf, ngx_command_t *cmd, void *conf)
     /* compile the CMDS argument */
 
     rlcf->complex_query = ngx_palloc(cf->pool,
-            sizeof(ngx_http_complex_value_t));
+                                     sizeof(ngx_http_complex_value_t));
 
     if (rlcf->complex_query == NULL) {
         return NGX_CONF_ERROR;
diff --git a/src/ngx_http_redis2_util.c b/src/ngx_http_redis2_util.c
@@ -65,15 +65,15 @@ ngx_http_redis2_upstream_add(ngx_http_request_t *r, ngx_url_t *url)
 
         if (uscfp[i]->host.len != url->host.len
             || ngx_strncasecmp(uscfp[i]->host.data, url->host.data,
-               url->host.len) != 0)
+                               url->host.len) != 0)
         {
             dd("upstream_add: host not match");
             continue;
         }
 
         if (uscfp[i]->port != url->port) {
             dd("upstream_add: port not match: %d != %d",
-                    (int) uscfp[i]->port, (int) url->port);
+               (int) uscfp[i]->port, (int) url->port);
             continue;
         }
 
@@ -203,8 +203,8 @@ ngx_http_redis2_build_query(ngx_http_request_t *r, ngx_array_t *queries,
 
     if (p - (*b)->pos != (ssize_t) len) {
         ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,
-                "redis2: redis2_query buffer error %uz != %uz",
-                (size_t) (p - (*b)->pos), len);
+                      "redis2: redis2_query buffer error %uz != %uz",
+                      (size_t) (p - (*b)->pos), len);
 
         return NGX_ERROR;
     }

Original file line number	Diff line number	Diff line change
`@@ -44,14 +44,14 @@ ngx_http_redis2_handler(ngx_http_request_t *r)`
`44`	`44`	`/* variables used in the redis2_pass directive */`
`45`	`45`
`46`	`46`	`if (ngx_http_complex_value(r, rlcf->complex_target, &target)`
`47`		`- != NGX_OK)`
	`47`	`+ != NGX_OK)`
`48`	`48`	`{`
`49`	`49`	`return NGX_ERROR;`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`if (target.len == 0) {`
`53`	`53`	`ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,`
`54`		`- "handler: empty \"redis2_pass\" target");`
	`54`	`+ "handler: empty \"redis2_pass\" target");`
`55`	`55`	`return NGX_HTTP_INTERNAL_SERVER_ERROR;`
`56`	`56`	`}`
`57`	`57`
`@@ -63,7 +63,7 @@ ngx_http_redis2_handler(ngx_http_request_t *r)`
`63`	`63`
`64`	`64`	`if (rlcf->upstream.upstream == NULL) {`
`65`	`65`	`ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,`
`66`		`- "redis2: upstream \"%V\" not found", &target);`
	`66`	`+ "redis2: upstream \"%V\" not found", &target);`
`67`	`67`
`68`	`68`	`return NGX_HTTP_INTERNAL_SERVER_ERROR;`
`69`	`69`	`}`
`@@ -131,20 +131,20 @@ ngx_http_redis2_create_request(ngx_http_request_t *r)`
`131`	`131`	`} else if (rlcf->literal_query.len == 0) {`
`132`	`132`	`if (rlcf->complex_query == NULL) {`
`133`	`133`	`ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,`
`134`		`- "no redis2 query specified or the query is empty");`
	`134`	`+ "no redis2 query specified or the query is empty");`
`135`	`135`
`136`	`136`	`return NGX_ERROR;`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`if (ngx_http_complex_value(r, rlcf->complex_query, &query)`
`140`		`- != NGX_OK)`
	`140`	`+ != NGX_OK)`
`141`	`141`	`{`
`142`	`142`	`return NGX_ERROR;`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`if (query.len == 0) {`
`146`	`146`	`ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,`
`147`		`- "the redis query is empty");`
	`147`	`+ "the redis query is empty");`
`148`	`148`
`149`	`149`	`return NGX_ERROR;`
`150`	`150`	`}`
`@@ -154,22 +154,24 @@ ngx_http_redis2_create_request(ngx_http_request_t *r)`
`154`	`154`
`155`	`155`	`} else {`
`156`	`156`	`if (ngx_http_complex_value(r, rlcf->complex_query_count,`
`157`		`- &query_count) != NGX_OK)`
	`157`	`+ &query_count)`
	`158`	`+ != NGX_OK)`
`158`	`159`	`{`
`159`	`160`	`return NGX_ERROR;`
`160`	`161`	`}`
`161`	`162`
`162`	`163`	`if (query_count.len == 0) {`
`163`	`164`	`ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,`
`164`		`- "the N argument to redis2_raw_queries is empty");`
	`165`	`+ "the N argument to redis2_raw_queries is empty");`
`165`	`166`
`166`	`167`	`return NGX_ERROR;`
`167`	`168`	`}`
`168`	`169`
`169`	`170`	`n = ngx_atoi(query_count.data, query_count.len);`
`170`	`171`	`if (n == NGX_ERROR \|\| n == 0) {`
`171`	`172`	`ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,`
`172`		`- "the N argument to redis2_raw_queries is invalid");`
	`173`	`+ "the N argument to redis2_raw_queries is "`
	`174`	`+ "invalid");`
`173`	`175`
`174`	`176`	`return NGX_ERROR;`
`175`	`177`	`}`
Original file line number	Diff line number	Diff line change
`@@ -65,15 +65,15 @@ ngx_http_redis2_upstream_add(ngx_http_request_t r, ngx_url_t url)`
`65`	`65`
`66`	`66`	`if (uscfp[i]->host.len != url->host.len`
`67`	`67`	`\|\| ngx_strncasecmp(uscfp[i]->host.data, url->host.data,`
`68`		`- url->host.len) != 0)`
	`68`	`+ url->host.len) != 0)`
`69`	`69`	`{`
`70`	`70`	`dd("upstream_add: host not match");`
`71`	`71`	`continue;`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`if (uscfp[i]->port != url->port) {`
`75`	`75`	`dd("upstream_add: port not match: %d != %d",`
`76`		`- (int) uscfp[i]->port, (int) url->port);`
	`76`	`+ (int) uscfp[i]->port, (int) url->port);`
`77`	`77`	`continue;`
`78`	`78`	`}`
`79`	`79`
`@@ -203,8 +203,8 @@ ngx_http_redis2_build_query(ngx_http_request_t r, ngx_array_t queries,`
`203`	`203`
`204`	`204`	`if (p - (*b)->pos != (ssize_t) len) {`
`205`	`205`	`ngx_log_error(NGX_LOG_ERR, r->connection->log, 0,`
`206`		`- "redis2: redis2_query buffer error %uz != %uz",`
`207`		`- (size_t) (p - (*b)->pos), len);`
	`206`	`+ "redis2: redis2_query buffer error %uz != %uz",`
	`207`	`+ (size_t) (p - (*b)->pos), len);`
`208`	`208`
`209`	`209`	`return NGX_ERROR;`
`210`	`210`	`}`