示例#1
0
struct rwmain_gi * rwmain_gi_new(rwpb_gi_RwManifest_Manifest * manifest_box) 
{
  rw_status_t status;
  struct rwmain_gi * rwmain;
  struct rwvx_instance_s * rwvx;
  vcs_manifest * manifest;
  extern char **environ;
  char *s;
  int i;
  char * parent = NULL;
  char * ip_address = NULL;

  if (!getenv("TEST_ENVIRON")) {
    return rwmain_gi_old(manifest_box);
  }

  rwvx = rwvx_instance_alloc();
   
  RW_ASSERT(rwvx);

  s = *environ;
  for (i=0; s; i++) {
    rwvx->rwvcs->envp = realloc(rwvx->rwvcs->envp, (i+1)*sizeof(char*));
    rwvx->rwvcs->envp[i] = strdup(s);
    s = *(environ+i+1);
  }
  rwvx->rwvcs->envp = realloc(rwvx->rwvcs->envp, (i+1)*sizeof(char*));
  rwvx->rwvcs->envp[i] = NULL;

 
  RW_ASSERT(manifest_box->box.message->descriptor == RWPB_G_MSG_PBCMD(RwManifest_Manifest));
  manifest = (vcs_manifest *)manifest_box->box.message;
  sanitize_manifest(manifest);
  char *manifest_file = getenv("RW_MANIFEST");
  if (!manifest_file) {
    rwvx->rwvcs->pb_rwmanifest = (vcs_manifest *)protobuf_c_message_duplicate(
      NULL,
      &manifest->base,
      manifest->base.descriptor);
  }
  if (g_pb_rwmanifest) {
    protobuf_c_message_free_unpacked(NULL, &g_pb_rwmanifest->base);
  }
  g_pb_rwmanifest = (vcs_manifest *)protobuf_c_message_duplicate(
                    NULL, &manifest->base,
                    manifest->base.descriptor); /* used for module / unit test hack */

  char cn[1024];

  status = rwvcs_variable_evaluate_str(
      rwvx->rwvcs,
      "$rw_component_name",
      cn,
      sizeof(cn));

  rwvcs_process_manifest_file (rwvx->rwvcs, getenv("RW_MANIFEST"));
  if(!(cn[0])) {
    ip_address = rwvcs_manifest_get_local_mgmt_addr(rwvx->rwvcs->pb_rwmanifest->bootstrap_phase);
    RW_ASSERT(ip_address);
  }
  rwvcs_manifest_setup_mgmt_info (rwvx->rwvcs, !(cn[0]), ip_address);
  if (manifest_file) {
     status = rwvcs_instance_init(rwvx->rwvcs, 
                               getenv("RW_MANIFEST"), 
                               ip_address, 
                               NULL,
                               main_function);
  }
  else {
    status = rwvcs_instance_init(rwvx->rwvcs, NULL, ip_address, NULL, rwmain_gi_function);
  }
  RW_ASSERT(status == RW_STATUS_SUCCESS);

  char *component_name = NULL;
  char *component_type = NULL;
  uint32_t instance_id = 0;
  uint32_t vm_instance_id = 0;
  rwmain = rwmain_alloc(rwvx, component_name, instance_id, component_type, parent, ip_address, vm_instance_id);
  RW_ASSERT(rwmain);
  {
    rwmain->rwvx->rwvcs->apih = rwmain->dts;
    RW_SKLIST_PARAMS_DECL(
        config_ready_entries_,
        rwvcs_config_ready_entry_t,
        instance_name,
        rw_sklist_comp_charptr,
        config_ready_elem);
    RW_SKLIST_INIT(
        &(rwmain->rwvx->rwvcs->config_ready_entries), 
        &config_ready_entries_);
    rwmain->rwvx->rwvcs->config_ready_fn = rwmain_dts_config_ready_process;
  }
    

  if (rwmain->vm_ip_address) {
    rwmain->rwvx->rwvcs->identity.vm_ip_address = strdup(rwmain->vm_ip_address);
    RW_ASSERT(rwmain->rwvx->rwvcs->identity.vm_ip_address);
  }
  rwmain->rwvx->rwvcs->identity.rwvm_instance_id = rwmain->vm_instance_id;

  if (rwmain->component_type == RWVCS_TYPES_COMPONENT_TYPE_RWVM) {
    RW_ASSERT(VCS_GET(rwmain)->instance_name);
    rwmain->rwvx->rwvcs->identity.rwvm_name = strdup(VCS_GET(rwmain)->instance_name);
  }
  else if (rwmain->component_type == RWVCS_TYPES_COMPONENT_TYPE_RWPROC) {
    RW_ASSERT(rwmain->parent_id);
    rwmain->rwvx->rwvcs->identity.rwvm_name = strdup(rwmain->parent_id);
  }

  {
    char instance_id_str[256];
    snprintf(instance_id_str, 256, "%u", rwmain->vm_instance_id);
  }

  if (rwmain->component_type == RWVCS_TYPES_COMPONENT_TYPE_RWVM && parent!=NULL) {
    rwvcs_instance_ptr_t rwvcs = rwvx->rwvcs;
    struct timeval timeout = { .tv_sec = RWVCS_RWZK_TIMEOUT_S, .tv_usec = 0 };
    rw_component_info rwvm_info;
    char * instance_name = NULL;
    instance_name = to_instance_name(component_name, instance_id);
    RW_ASSERT(instance_name!=NULL);
    // Lock so that the parent can initialize the zk data before the child updates it
    status = rwvcs_rwzk_lock(rwvcs, instance_name, &timeout);
    RW_ASSERT(status == RW_STATUS_SUCCESS);
    printf("instance_nameinstance_nameinstance_nameinstance_nameinstance_name=%s\n", instance_name);
    status = rwvcs_rwzk_lookup_component(rwvcs, instance_name, &rwvm_info);
    RW_ASSERT(status == RW_STATUS_SUCCESS);
    RW_ASSERT(rwvm_info.vm_info!=NULL);
    rwvm_info.vm_info->has_pid = true;
    rwvm_info.vm_info->pid = getpid();
    status = rwvcs_rwzk_node_update(rwvcs, &rwvm_info);
    RW_ASSERT(status == RW_STATUS_SUCCESS);
    status = rwvcs_rwzk_unlock(rwvcs, instance_name);
    RW_ASSERT(status == RW_STATUS_SUCCESS);
    free(instance_name);
  } else if (rwmain->component_type == RWVCS_TYPES_COMPONENT_TYPE_RWVM && parent == NULL) {
示例#2
0
/*
 * Initialize the zookeeper with a node for this component.  Used when the
 * component does not have a parent and therefore no one created the zookeeper
 * node yet.
 */
rw_status_t update_zk(struct rwmain_gi * rwmain)
{
  rw_status_t status;
  vcs_manifest_component * mdef;
  rwvcs_instance_ptr_t rwvcs;
  char * id = NULL;
  rw_component_info * ci = NULL;


  rwvcs = rwmain->rwvx->rwvcs;

  RW_ASSERT(!rwmain->parent_id);
  id = to_instance_name(rwmain->component_name, rwmain->instance_id);

  // As we only hit this point when the parent_id is NULL, we are pretty much
  // guaranteed that the definition has to be in the static manifest.
  status = rwvcs_manifest_component_lookup(rwvcs, rwmain->component_name, &mdef);
  if (status != RW_STATUS_SUCCESS) {
    RW_CRASH();
    goto done;
  }


  if (mdef->component_type == RWVCS_TYPES_COMPONENT_TYPE_RWVM) {
    ci = rwvcs_rwvm_alloc(
        rwmain->rwvx->rwvcs,
        rwmain->parent_id,
        rwmain->component_name,
        rwmain->instance_id,
        id);
    if (!ci) {
      RW_CRASH();
      status = RW_STATUS_FAILURE;
      goto done;
    }

    ci->vm_info->vm_ip_address = strdup(rwmain->vm_ip_address);
    ci->vm_info->has_pid = true;
    ci->vm_info->pid = getpid();
    ci->has_state = true;
    ci->state = RW_BASE_STATE_TYPE_STARTING;

    if (mdef->rwvm && mdef->rwvm->has_leader) {
      ci->vm_info->has_leader = true;
      ci->vm_info->leader= mdef->rwvm->leader;
    }
  } else if (mdef->component_type == RWVCS_TYPES_COMPONENT_TYPE_RWPROC) {
    ci = rwvcs_rwproc_alloc(
        rwvcs,
        rwmain->parent_id,
        rwmain->component_name,
        rwmain->instance_id,
        id);
    if (!ci) {
      RW_CRASH();
      status = RW_STATUS_FAILURE;
      goto done;
    }

    ci->proc_info->has_pid = true;
    ci->proc_info->pid = getpid();
    ci->has_state = true;
    ci->proc_info->has_native = true;
    ci->proc_info->native = false;
    ci->state = RW_BASE_STATE_TYPE_STARTING;
  } else {
    RW_CRASH();
    status = RW_STATUS_FAILURE;
    goto done;
  }

  status = rwvcs_rwzk_node_update(rwmain->rwvx->rwvcs, ci);
  if (status != RW_STATUS_SUCCESS) {
    RW_CRASH();
    goto done;
  }


done:
  if (id)
    free(id);

  if (ci)
    protobuf_free(ci);

  return status;
}