grpc 0.13.1 → 0.14.1.pre1

data/src/core/{channel → ext/client_config}/subchannel_call_holder.c

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright 2015-2016, Google Inc.
+ * Copyright 2015, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,11 +31,11 @@
  *
  */
 
-#include "src/core/channel/subchannel_call_holder.h"
+#include "src/core/ext/client_config/subchannel_call_holder.h"
 
 #include <grpc/support/alloc.h>
 
-#include "src/core/profiling/timers.h"
+#include "src/core/lib/profiling/timers.h"
 
 #define GET_CALL(holder) \
   ((grpc_subchannel_call *)(gpr_atm_acq_load(&(holder)->subchannel_call)))
@@ -127,7 +127,7 @@ retry:
           break;
         case GRPC_SUBCHANNEL_CALL_HOLDER_PICKING_SUBCHANNEL:
           holder->pick_subchannel(exec_ctx, holder->pick_subchannel_arg, NULL,
-                                  &holder->connected_subchannel, NULL);
+                                  0, &holder->connected_subchannel, NULL);
           break;
       }
       gpr_mu_unlock(&holder->mu);
@@ -145,7 +145,8 @@ retry:
     GRPC_CALL_STACK_REF(holder->owning_call, "pick_subchannel");
     if (holder->pick_subchannel(
             exec_ctx, holder->pick_subchannel_arg, op->send_initial_metadata,
-            &holder->connected_subchannel, &holder->next_step)) {
+            op->send_initial_metadata_flags, &holder->connected_subchannel,
+            &holder->next_step)) {
       holder->creation_phase = GRPC_SUBCHANNEL_CALL_HOLDER_NOT_CREATING;
       GRPC_CALL_STACK_UNREF(exec_ctx, holder->owning_call, "pick_subchannel");
     }
@@ -251,9 +252,9 @@ char *grpc_subchannel_call_holder_get_peer(
     grpc_exec_ctx *exec_ctx, grpc_subchannel_call_holder *holder) {
   grpc_subchannel_call *subchannel_call = GET_CALL(holder);
 
-  if (subchannel_call) {
-    return grpc_subchannel_call_get_peer(exec_ctx, subchannel_call);
-  } else {
+  if (subchannel_call == NULL || subchannel_call == CANCELLED_CALL) {
     return NULL;
+  } else {
+    return grpc_subchannel_call_get_peer(exec_ctx, subchannel_call);
   }
 }

data/src/core/{channel → ext/client_config}/subchannel_call_holder.h

@@ -31,10 +31,10 @@
  *
  */
 
-#ifndef GRPC_INTERNAL_CORE_CHANNEL_SUBCHANNEL_CALL_HOLDER_H
-#define GRPC_INTERNAL_CORE_CHANNEL_SUBCHANNEL_CALL_HOLDER_H
+#ifndef GRPC_CORE_EXT_CLIENT_CONFIG_SUBCHANNEL_CALL_HOLDER_H
+#define GRPC_CORE_EXT_CLIENT_CONFIG_SUBCHANNEL_CALL_HOLDER_H
 
-#include "src/core/client_config/subchannel.h"
+#include "src/core/ext/client_config/subchannel.h"
 
 /** Pick a subchannel for grpc_subchannel_call_holder;
     Return 1 if subchannel is available immediately (in which case on_ready
@@ -42,6 +42,7 @@
     called when the subchannel is available) */
 typedef int (*grpc_subchannel_call_holder_pick_subchannel)(
     grpc_exec_ctx *exec_ctx, void *arg, grpc_metadata_batch *initial_metadata,
+    uint32_t initial_metadata_flags,
     grpc_connected_subchannel **connected_subchannel, grpc_closure *on_ready);
 
 typedef enum {
@@ -55,15 +56,14 @@ typedef enum {
     for initial metadata before trying to create a call object,
     and handling cancellation gracefully.
 
-    Both the channel and uchannel filter use this as their call_data. */
+    The channel filter uses this as their call_data. */
 typedef struct grpc_subchannel_call_holder {
   /** either 0 for no call, 1 for cancelled, or a pointer to a
       grpc_subchannel_call */
   gpr_atm subchannel_call;
   /** Helper function to choose the subchannel on which to create
       the call object. Channel filter delegates to the load
-      balancing policy (once it's ready); uchannel returns
-      immediately */
+      balancing policy (once it's ready). */
   grpc_subchannel_call_holder_pick_subchannel pick_subchannel;
   void *pick_subchannel_arg;
 
@@ -95,4 +95,4 @@ void grpc_subchannel_call_holder_perform_op(grpc_exec_ctx *exec_ctx,
 char *grpc_subchannel_call_holder_get_peer(grpc_exec_ctx *exec_ctx,
                                            grpc_subchannel_call_holder *holder);
 
-#endif
+#endif /* GRPC_CORE_EXT_CLIENT_CONFIG_SUBCHANNEL_CALL_HOLDER_H */

data/src/core/{client_config → ext/client_config}/subchannel_index.c

@@ -31,7 +31,7 @@
 //
 //
 
-#include "src/core/client_config/subchannel_index.h"
+#include "src/core/ext/client_config/subchannel_index.h"
 
 #include <stdbool.h>
 #include <string.h>
@@ -40,7 +40,7 @@
 #include <grpc/support/avl.h>
 #include <grpc/support/tls.h>
 
-#include "src/core/channel/channel_args.h"
+#include "src/core/lib/channel/channel_args.h"
 
 // a map of subchannel_key --> subchannel, used for detecting connections
 // to the same destination in order to share them
@@ -108,6 +108,7 @@ static int subchannel_key_compare(grpc_subchannel_key *a,
   if (c != 0) return c;
   c = memcmp(a->args.filters, b->args.filters,
              a->args.filter_count * sizeof(*a->args.filters));
+  if (c != 0) return c;
   return grpc_channel_args_compare(a->args.args, b->args.args);
 }
 

data/src/core/{client_config → ext/client_config}/subchannel_index.h

@@ -31,11 +31,11 @@
  *
  */
 
-#ifndef GRPC_INTERNAL_CORE_CLIENT_CONFIG_SUBCHANNEL_INDEX_H
-#define GRPC_INTERNAL_CORE_CLIENT_CONFIG_SUBCHANNEL_INDEX_H
+#ifndef GRPC_CORE_EXT_CLIENT_CONFIG_SUBCHANNEL_INDEX_H
+#define GRPC_CORE_EXT_CLIENT_CONFIG_SUBCHANNEL_INDEX_H
 
-#include "src/core/client_config/connector.h"
-#include "src/core/client_config/subchannel.h"
+#include "src/core/ext/client_config/connector.h"
+#include "src/core/ext/client_config/subchannel.h"
 
 /** \file Provides an index of active subchannels so that they can be
     shared amongst channels */
@@ -74,4 +74,4 @@ void grpc_subchannel_index_init(void);
 /** Shutdown the subchannel index (global) */
 void grpc_subchannel_index_shutdown(void);
 
-#endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_SUBCHANNEL_INDEX_H */
+#endif /* GRPC_CORE_EXT_CLIENT_CONFIG_SUBCHANNEL_INDEX_H */

data/src/core/{client_config → ext/client_config}/uri_parser.c

@@ -31,15 +31,19 @@
  *
  */
 
-#include "src/core/client_config/uri_parser.h"
+#include "src/core/ext/client_config/uri_parser.h"
 
 #include <string.h>
 
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 #include <grpc/support/port_platform.h>
+#include <grpc/support/slice.h>
+#include <grpc/support/slice_buffer.h>
 #include <grpc/support/string_util.h>
 
+#include "src/core/lib/support/string.h"
+
 /** a size_t default value... maps to all 1's */
 #define NOT_SET (~(size_t)0)
 
@@ -133,6 +137,51 @@ static int parse_fragment_or_query(const char *uri_text, size_t *i) {
   return 1;
 }
 
+static void do_nothing(void *ignored) {}
+static void parse_query_parts(grpc_uri *uri) {
+  static const char *QUERY_PARTS_SEPARATOR = "&";
+  static const char *QUERY_PARTS_VALUE_SEPARATOR = "=";
+  GPR_ASSERT(uri->query != NULL);
+  if (uri->query[0] == '\0') {
+    uri->query_parts = NULL;
+    uri->query_parts_values = NULL;
+    uri->num_query_parts = 0;
+    return;
+  }
+  gpr_slice query_slice =
+      gpr_slice_new(uri->query, strlen(uri->query), do_nothing);
+  gpr_slice_buffer query_parts; /* the &-separated elements of the query */
+  gpr_slice_buffer query_param_parts; /* the =-separated subelements */
+
+  gpr_slice_buffer_init(&query_parts);
+  gpr_slice_buffer_init(&query_param_parts);
+
+  gpr_slice_split(query_slice, QUERY_PARTS_SEPARATOR, &query_parts);
+  uri->query_parts = gpr_malloc(query_parts.count * sizeof(char *));
+  uri->query_parts_values = gpr_malloc(query_parts.count * sizeof(char *));
+  uri->num_query_parts = query_parts.count;
+  for (size_t i = 0; i < query_parts.count; i++) {
+    gpr_slice_split(query_parts.slices[i], QUERY_PARTS_VALUE_SEPARATOR,
+                    &query_param_parts);
+    GPR_ASSERT(query_param_parts.count > 0);
+    uri->query_parts[i] =
+        gpr_dump_slice(query_param_parts.slices[0], GPR_DUMP_ASCII);
+    if (query_param_parts.count > 1) {
+      /* TODO(dgq): only the first value after the separator is considered.
+       * Perhaps all chars after the first separator for the query part should
+       * be included, even if they include the separator. */
+      uri->query_parts_values[i] =
+          gpr_dump_slice(query_param_parts.slices[1], GPR_DUMP_ASCII);
+    } else {
+      uri->query_parts_values[i] = NULL;
+    }
+    gpr_slice_buffer_reset_and_unref(&query_param_parts);
+  }
+  gpr_slice_buffer_destroy(&query_parts);
+  gpr_slice_buffer_destroy(&query_param_parts);
+  gpr_slice_unref(query_slice);
+}
+
 grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors) {
   grpc_uri *uri;
   size_t scheme_begin = 0;
@@ -227,16 +276,35 @@ grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors) {
   uri->path = copy_component(uri_text, path_begin, path_end);
   uri->query = copy_component(uri_text, query_begin, query_end);
   uri->fragment = copy_component(uri_text, fragment_begin, fragment_end);
+  parse_query_parts(uri);
 
   return uri;
 }
 
+const char *grpc_uri_get_query_arg(const grpc_uri *uri, const char *key) {
+  GPR_ASSERT(key != NULL);
+  if (key[0] == '\0') return NULL;
+
+  for (size_t i = 0; i < uri->num_query_parts; ++i) {
+    if (0 == strcmp(key, uri->query_parts[i])) {
+      return uri->query_parts_values[i];
+    }
+  }
+  return NULL;
+}
+
 void grpc_uri_destroy(grpc_uri *uri) {
   if (!uri) return;
   gpr_free(uri->scheme);
   gpr_free(uri->authority);
   gpr_free(uri->path);
   gpr_free(uri->query);
+  for (size_t i = 0; i < uri->num_query_parts; ++i) {
+    gpr_free(uri->query_parts[i]);
+    gpr_free(uri->query_parts_values[i]);
+  }
+  gpr_free(uri->query_parts);
+  gpr_free(uri->query_parts_values);
   gpr_free(uri->fragment);
   gpr_free(uri);
 }

data/src/core/{client_config → ext/client_config}/uri_parser.h

@@ -31,21 +31,33 @@
  *
  */
 
-#ifndef GRPC_INTERNAL_CORE_CLIENT_CONFIG_URI_PARSER_H
-#define GRPC_INTERNAL_CORE_CLIENT_CONFIG_URI_PARSER_H
+#ifndef GRPC_CORE_EXT_CLIENT_CONFIG_URI_PARSER_H
+#define GRPC_CORE_EXT_CLIENT_CONFIG_URI_PARSER_H
+
+#include <stddef.h>
 
 typedef struct {
   char *scheme;
   char *authority;
   char *path;
   char *query;
+  /** Query substrings separated by '&' */
+  char **query_parts;
+  /** Number of elements in \a query_parts and \a query_parts_values */
+  size_t num_query_parts;
+  /** Split each query part by '='. NULL if not present. */
+  char **query_parts_values;
   char *fragment;
 } grpc_uri;
 
 /** parse a uri, return NULL on failure */
 grpc_uri *grpc_uri_parse(const char *uri_text, int suppress_errors);
 
+/** return the part of a query string after the '=' in "?key=xxx&...", or NULL
+ * if key is not present */
+const char *grpc_uri_get_query_arg(const grpc_uri *uri, const char *key);
+
 /** destroy a uri */
 void grpc_uri_destroy(grpc_uri *uri);
 
-#endif
+#endif /* GRPC_CORE_EXT_CLIENT_CONFIG_URI_PARSER_H */

data/src/core/{client_config/lb_policies → ext/lb_policy/grpclb}/load_balancer_api.c

@@ -31,7 +31,7 @@
  *
  */
 
-#include "src/core/client_config/lb_policies/load_balancer_api.h"
+#include "src/core/ext/lb_policy/grpclb/load_balancer_api.h"
 #include "third_party/nanopb/pb_decode.h"
 #include "third_party/nanopb/pb_encode.h"
 
@@ -110,13 +110,15 @@ grpc_grpclb_response *grpc_grpclb_response_parse(gpr_slice encoded_response) {
   grpc_grpclb_response *res = gpr_malloc(sizeof(grpc_grpclb_response));
   memset(res, 0, sizeof(*res));
   status = pb_decode(&stream, grpc_lb_v0_LoadBalanceResponse_fields, res);
-  GPR_ASSERT(status == true);
+  if (!status) {
+    grpc_grpclb_response_destroy(res);
+    return NULL;
+  }
   return res;
 }
 
 grpc_grpclb_serverlist *grpc_grpclb_response_parse_serverlist(
     gpr_slice encoded_response) {
-  grpc_grpclb_serverlist *sl = gpr_malloc(sizeof(grpc_grpclb_serverlist));
   bool status;
   decode_serverlist_arg arg;
   pb_istream_t stream =
@@ -131,15 +133,20 @@ grpc_grpclb_serverlist *grpc_grpclb_response_parse_serverlist(
   res->server_list.servers.arg = &arg;
   arg.first_pass = 1;
   status = pb_decode(&stream, grpc_lb_v0_LoadBalanceResponse_fields, res);
-  GPR_ASSERT(status == true);
-  GPR_ASSERT(arg.num_servers > 0);
+  if (!status) {
+    grpc_grpclb_response_destroy(res);
+    return NULL;
+  }
 
   arg.first_pass = 0;
   status =
       pb_decode(&stream_at_start, grpc_lb_v0_LoadBalanceResponse_fields, res);
-  GPR_ASSERT(status == true);
-  GPR_ASSERT(arg.servers != NULL);
+  if (!status) {
+    grpc_grpclb_response_destroy(res);
+    return NULL;
+  }
 
+  grpc_grpclb_serverlist *sl = gpr_malloc(sizeof(grpc_grpclb_serverlist));
   sl->num_servers = arg.num_servers;
   sl->servers = arg.servers;
   if (res->server_list.has_expiration_interval) {
@@ -150,8 +157,10 @@ grpc_grpclb_serverlist *grpc_grpclb_response_parse_serverlist(
 }
 
 void grpc_grpclb_destroy_serverlist(grpc_grpclb_serverlist *serverlist) {
-  size_t i;
-  for (i = 0; i < serverlist->num_servers; i++) {
+  if (serverlist == NULL) {
+    return;
+  }
+  for (size_t i = 0; i < serverlist->num_servers; i++) {
     gpr_free(serverlist->servers[i]);
   }
   gpr_free(serverlist->servers);

data/src/core/{client_config/lb_policies → ext/lb_policy/grpclb}/load_balancer_api.h

@@ -31,13 +31,13 @@
  *
  */
 
-#ifndef GRPC_INTERNAL_CORE_CLIENT_CONFIG_LB_POLICIES_LOAD_BALANCER_API_H
-#define GRPC_INTERNAL_CORE_CLIENT_CONFIG_LB_POLICIES_LOAD_BALANCER_API_H
+#ifndef GRPC_CORE_EXT_LB_POLICY_GRPCLB_LOAD_BALANCER_API_H
+#define GRPC_CORE_EXT_LB_POLICY_GRPCLB_LOAD_BALANCER_API_H
 
 #include <grpc/support/slice_buffer.h>
 
-#include "src/core/client_config/lb_policy_factory.h"
-#include "src/core/proto/grpc/lb/v0/load_balancer.pb.h"
+#include "src/core/ext/client_config/lb_policy_factory.h"
+#include "src/core/ext/lb_policy/grpclb/proto/grpc/lb/v0/load_balancer.pb.h"
 
 #ifdef __cplusplus
 extern "C" {
@@ -82,4 +82,4 @@ void grpc_grpclb_response_destroy(grpc_grpclb_response *response);
 }
 #endif
 
-#endif /* GRPC_INTERNAL_CORE_CLIENT_CONFIG_LB_POLICIES_LOAD_BALANCER_API_H */
+#endif /* GRPC_CORE_EXT_LB_POLICY_GRPCLB_LOAD_BALANCER_API_H */

data/src/core/{proto → ext/lb_policy/grpclb/proto}/grpc/lb/v0/load_balancer.pb.c

@@ -33,7 +33,7 @@
 /* Automatically generated nanopb constant definitions */
 /* Generated by nanopb-0.3.5-dev */
 
-#include "src/core/proto/grpc/lb/v0/load_balancer.pb.h"
+#include "src/core/ext/lb_policy/grpclb/proto/grpc/lb/v0/load_balancer.pb.h"
 
 #if PB_PROTO_HEADER_VERSION != 30
 #error Regenerate this file with the current version of nanopb generator.

data/src/core/{client_config/lb_policies → ext/lb_policy/pick_first}/pick_first.c

@@ -1,6 +1,6 @@
 /*
  *
- * Copyright 2015-2016, Google Inc.
+ * Copyright 2015, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -31,17 +31,16 @@
  *
  */
 
-#include "src/core/client_config/lb_policies/pick_first.h"
-#include "src/core/client_config/lb_policy_factory.h"
-
 #include <string.h>
 
 #include <grpc/support/alloc.h>
-#include "src/core/transport/connectivity_state.h"
+#include "src/core/ext/client_config/lb_policy_registry.h"
+#include "src/core/lib/transport/connectivity_state.h"
 
 typedef struct pending_pick {
   struct pending_pick *next;
   grpc_pollset *pollset;
+  uint32_t initial_metadata_flags;
   grpc_connected_subchannel **target;
   grpc_closure *on_complete;
 } pending_pick;
@@ -78,7 +77,7 @@ typedef struct {
 #define GET_SELECTED(p) \
   ((grpc_connected_subchannel *)gpr_atm_acq_load(&(p)->selected))
 
-void pf_destroy(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
+static void pf_destroy(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
   pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
   grpc_connected_subchannel *selected = GET_SELECTED(p);
   size_t i;
@@ -95,7 +94,7 @@ void pf_destroy(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
   gpr_free(p);
 }
 
-void pf_shutdown(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
+static void pf_shutdown(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
   pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
   pending_pick *pp;
   grpc_connected_subchannel *selected;
@@ -110,7 +109,7 @@ void pf_shutdown(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
   if (selected != NULL) {
     grpc_connected_subchannel_notify_on_state_change(
         exec_ctx, selected, NULL, NULL, &p->connectivity_changed);
-  } else {
+  } else if (p->num_subchannels > 0) {
     grpc_subchannel_notify_on_state_change(
         exec_ctx, p->subchannels[p->checking_subchannel], NULL, NULL,
         &p->connectivity_changed);
@@ -151,6 +150,31 @@ static void pf_cancel_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
   gpr_mu_unlock(&p->mu);
 }
 
+static void pf_cancel_picks(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
+                            uint32_t initial_metadata_flags_mask,
+                            uint32_t initial_metadata_flags_eq) {
+  pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
+  pending_pick *pp;
+  gpr_mu_lock(&p->mu);
+  pp = p->pending_picks;
+  p->pending_picks = NULL;
+  while (pp != NULL) {
+    pending_pick *next = pp->next;
+    if ((pp->initial_metadata_flags & initial_metadata_flags_mask) ==
+        initial_metadata_flags_eq) {
+      grpc_pollset_set_del_pollset(exec_ctx, p->base.interested_parties,
+                                   pp->pollset);
+      grpc_exec_ctx_enqueue(exec_ctx, pp->on_complete, false, NULL);
+      gpr_free(pp);
+    } else {
+      pp->next = p->pending_picks;
+      p->pending_picks = pp;
+    }
+    pp = next;
+  }
+  gpr_mu_unlock(&p->mu);
+}
+
 static void start_picking(grpc_exec_ctx *exec_ctx, pick_first_lb_policy *p) {
   p->started_picking = 1;
   p->checking_subchannel = 0;
@@ -162,7 +186,7 @@ static void start_picking(grpc_exec_ctx *exec_ctx, pick_first_lb_policy *p) {
       &p->connectivity_changed);
 }
 
-void pf_exit_idle(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
+static void pf_exit_idle(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
   pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
   gpr_mu_lock(&p->mu);
   if (!p->started_picking) {
@@ -171,9 +195,11 @@ void pf_exit_idle(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol) {
   gpr_mu_unlock(&p->mu);
 }
 
-int pf_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol, grpc_pollset *pollset,
-            grpc_metadata_batch *initial_metadata,
-            grpc_connected_subchannel **target, grpc_closure *on_complete) {
+static int pf_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
+                   grpc_pollset *pollset, grpc_metadata_batch *initial_metadata,
+                   uint32_t initial_metadata_flags,
+                   grpc_connected_subchannel **target,
+                   grpc_closure *on_complete) {
   pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
   pending_pick *pp;
 
@@ -200,6 +226,7 @@ int pf_pick(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol, grpc_pollset *pollset,
     pp->next = p->pending_picks;
     pp->pollset = pollset;
     pp->target = target;
+    pp->initial_metadata_flags = initial_metadata_flags;
     pp->on_complete = on_complete;
     p->pending_picks = pp;
     gpr_mu_unlock(&p->mu);
@@ -287,11 +314,14 @@ static void pf_connectivity_changed(grpc_exec_ctx *exec_ctx, void *arg,
             &p->checking_connectivity, &p->connectivity_changed);
         break;
       case GRPC_CHANNEL_TRANSIENT_FAILURE:
-        grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
-                                    GRPC_CHANNEL_TRANSIENT_FAILURE,
-                                    "connecting_transient_failure");
         p->checking_subchannel =
             (p->checking_subchannel + 1) % p->num_subchannels;
+        if (p->checking_subchannel == 0) {
+          /* only trigger transient failure when we've tried all alternatives */
+          grpc_connectivity_state_set(exec_ctx, &p->state_tracker,
+                                      GRPC_CHANNEL_TRANSIENT_FAILURE,
+                                      "connecting_transient_failure");
+        }
         p->checking_connectivity = grpc_subchannel_check_connectivity(
             p->subchannels[p->checking_subchannel]);
         if (p->checking_connectivity == GRPC_CHANNEL_TRANSIENT_FAILURE) {
@@ -356,9 +386,10 @@ static grpc_connectivity_state pf_check_connectivity(grpc_exec_ctx *exec_ctx,
   return st;
 }
 
-void pf_notify_on_state_change(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
-                               grpc_connectivity_state *current,
-                               grpc_closure *notify) {
+static void pf_notify_on_state_change(grpc_exec_ctx *exec_ctx,
+                                      grpc_lb_policy *pol,
+                                      grpc_connectivity_state *current,
+                                      grpc_closure *notify) {
   pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
   gpr_mu_lock(&p->mu);
   grpc_connectivity_state_notify_on_state_change(exec_ctx, &p->state_tracker,
@@ -366,8 +397,8 @@ void pf_notify_on_state_change(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
   gpr_mu_unlock(&p->mu);
 }
 
-void pf_ping_one(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
-                 grpc_closure *closure) {
+static void pf_ping_one(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
+                        grpc_closure *closure) {
   pick_first_lb_policy *p = (pick_first_lb_policy *)pol;
   grpc_connected_subchannel *selected = GET_SELECTED(p);
   if (selected) {
@@ -378,26 +409,50 @@ void pf_ping_one(grpc_exec_ctx *exec_ctx, grpc_lb_policy *pol,
 }
 
 static const grpc_lb_policy_vtable pick_first_lb_policy_vtable = {
-    pf_destroy, pf_shutdown, pf_pick, pf_cancel_pick, pf_ping_one, pf_exit_idle,
-    pf_check_connectivity, pf_notify_on_state_change};
+    pf_destroy,     pf_shutdown,           pf_pick,
+    pf_cancel_pick, pf_cancel_picks,       pf_ping_one,
+    pf_exit_idle,   pf_check_connectivity, pf_notify_on_state_change};
 
 static void pick_first_factory_ref(grpc_lb_policy_factory *factory) {}
 
 static void pick_first_factory_unref(grpc_lb_policy_factory *factory) {}
 
-static grpc_lb_policy *create_pick_first(grpc_lb_policy_factory *factory,
+static grpc_lb_policy *create_pick_first(grpc_exec_ctx *exec_ctx,
+                                         grpc_lb_policy_factory *factory,
                                          grpc_lb_policy_args *args) {
+  GPR_ASSERT(args->addresses != NULL);
+  GPR_ASSERT(args->client_channel_factory != NULL);
+
+  if (args->addresses->naddrs == 0) return NULL;
+
   pick_first_lb_policy *p = gpr_malloc(sizeof(*p));
-  GPR_ASSERT(args->num_subchannels > 0);
   memset(p, 0, sizeof(*p));
-  grpc_lb_policy_init(&p->base, &pick_first_lb_policy_vtable);
+
   p->subchannels =
-      gpr_malloc(sizeof(grpc_subchannel *) * args->num_subchannels);
-  p->num_subchannels = args->num_subchannels;
-  grpc_connectivity_state_init(&p->state_tracker, GRPC_CHANNEL_IDLE,
-                               "pick_first");
-  memcpy(p->subchannels, args->subchannels,
-         sizeof(grpc_subchannel *) * args->num_subchannels);
+      gpr_malloc(sizeof(grpc_subchannel *) * args->addresses->naddrs);
+  memset(p->subchannels, 0, sizeof(*p->subchannels) * args->addresses->naddrs);
+  grpc_subchannel_args sc_args;
+  size_t subchannel_idx = 0;
+  for (size_t i = 0; i < args->addresses->naddrs; i++) {
+    memset(&sc_args, 0, sizeof(grpc_subchannel_args));
+    sc_args.addr = (struct sockaddr *)(args->addresses->addrs[i].addr);
+    sc_args.addr_len = (size_t)args->addresses->addrs[i].len;
+
+    grpc_subchannel *subchannel = grpc_client_channel_factory_create_subchannel(
+        exec_ctx, args->client_channel_factory, &sc_args);
+
+    if (subchannel != NULL) {
+      p->subchannels[subchannel_idx++] = subchannel;
+    }
+  }
+  if (subchannel_idx == 0) {
+    gpr_free(p->subchannels);
+    gpr_free(p);
+    return NULL;
+  }
+  p->num_subchannels = subchannel_idx;
+
+  grpc_lb_policy_init(&p->base, &pick_first_lb_policy_vtable);
   grpc_closure_init(&p->connectivity_changed, pf_connectivity_changed, p);
   gpr_mu_init(&p->mu);
   return &p->base;
@@ -410,6 +465,14 @@ static const grpc_lb_policy_factory_vtable pick_first_factory_vtable = {
 static grpc_lb_policy_factory pick_first_lb_policy_factory = {
     &pick_first_factory_vtable};
 
-grpc_lb_policy_factory *grpc_pick_first_lb_factory_create() {
+static grpc_lb_policy_factory *pick_first_lb_factory_create() {
   return &pick_first_lb_policy_factory;
 }
+
+/* Plugin registration */
+
+void grpc_lb_policy_pick_first_init() {
+  grpc_register_lb_policy(pick_first_lb_factory_create());
+}
+
+void grpc_lb_policy_pick_first_shutdown() {}