Esempio n. 1
0
lagopus_result_t
channel_mgr_channel_role_get(const char *channel_name,
                             datastore_controller_role_t *role) {
  uint32_t ofp_role;
  lagopus_result_t ret;
  struct channel *chan;


  ret = channel_mgr_channel_lookup_by_name(channel_name, &chan);
  if (ret != LAGOPUS_RESULT_OK) {
    return ret;
  }

  ofp_role = channel_role_get(chan);

  switch (ofp_role) {
    case OFPCR_ROLE_EQUAL:
      *role = DATASTORE_CONTROLLER_ROLE_EQUAL;
      break;
    case OFPCR_ROLE_MASTER:
      *role = DATASTORE_CONTROLLER_ROLE_MASTER;
      break;
    case OFPCR_ROLE_SLAVE:
      *role = DATASTORE_CONTROLLER_ROLE_SLAVE;
      break;
    default:
      *role = DATASTORE_CONTROLLER_ROLE_UNKNOWN;
      break;
  }

  return LAGOPUS_RESULT_OK;
}
Esempio n. 2
0
lagopus_result_t
channel_mgr_channel_local_addr_get(const char *channel_name,
                                   lagopus_ip_address_t **local_addr) {
  char ipaddr[INET6_ADDRSTRLEN+1];
  lagopus_result_t ret;
  struct channel *chan;
  struct addrunion addr = {0};

  ret = channel_mgr_channel_lookup_by_name(channel_name, &chan);
  if (ret != LAGOPUS_RESULT_OK) {
    return ret;
  }

  ret = channel_local_addr_get(chan, &addr);
  if (ret != LAGOPUS_RESULT_OK) {
    return ret;
  }

  if (addrunion_ipaddr_str_get(&addr, ipaddr, sizeof(ipaddr)) == NULL) {
    return LAGOPUS_RESULT_ANY_FAILURES;
  }

  ret = lagopus_ip_address_create(ipaddr,
                                  addrunion_af_get(&addr) == AF_INET ? true : false, local_addr);
  if (ret != LAGOPUS_RESULT_OK) {
    return ret;
  }

  return ret;
}
Esempio n. 3
0
void
test_channel_mgr_apis_fail(void) {
  lagopus_result_t ret;
  struct channel *chan = NULL;

  ret = channel_mgr_channel_lookup_by_name("hoge", &chan);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret);
  TEST_ASSERT_EQUAL(NULL, chan);
}
Esempio n. 4
0
lagopus_result_t
channel_mgr_channel_local_port_get(const char *channel_name,
                                   uint16_t *local_port) {
  lagopus_result_t ret;
  struct channel *chan;

  ret = channel_mgr_channel_lookup_by_name(channel_name, &chan);
  if (ret != LAGOPUS_RESULT_OK) {
    return ret;
  }

  return channel_local_port_get(chan, local_port);
}
Esempio n. 5
0
lagopus_result_t
channel_mgr_ofp_version_get(const char *channel_name, uint8_t *version) {
  lagopus_result_t ret;
  struct channel *chan;

  ret = channel_mgr_channel_lookup_by_name(channel_name, &chan);
  if (ret != LAGOPUS_RESULT_OK) {
    return ret;
  }

  *version = channel_version_get(chan);

  return LAGOPUS_RESULT_OK;
}
Esempio n. 6
0
lagopus_result_t
channel_mgr_controller_set(const char *channel_name,
                           datastore_controller_role_t role,
                           datastore_controller_connection_type_t type) {
  uint32_t ofp_role, prev_role;
  lagopus_result_t ret;
  struct channel *chan;

  ret = channel_mgr_channel_lookup_by_name(channel_name, &chan);
  if (ret != LAGOPUS_RESULT_OK) {
    return ret;
  }

  prev_role = channel_role_get(chan);

  switch (role) {
    case DATASTORE_CONTROLLER_ROLE_EQUAL:
      ofp_role = OFPCR_ROLE_EQUAL;
      break;
    case DATASTORE_CONTROLLER_ROLE_MASTER:
      ofp_role = OFPCR_ROLE_MASTER;
      break;
    case DATASTORE_CONTROLLER_ROLE_SLAVE:
      ofp_role = OFPCR_ROLE_SLAVE;
      break;
    default:
      return LAGOPUS_RESULT_INVALID_ARGS;
  }

  channel_role_set(chan, ofp_role);

  if (type == DATASTORE_CONTROLLER_CONNECTION_TYPE_MAIN) {
    ret = channel_auxiliary_set(chan, false);
  } else if (type == DATASTORE_CONTROLLER_CONNECTION_TYPE_AUXILIARY) {
    ret = channel_auxiliary_set(chan, true);
  } else {
    channel_role_set(chan, prev_role);
    return LAGOPUS_RESULT_INVALID_ARGS;
  }

  if (ret != LAGOPUS_RESULT_OK) {
    channel_role_set(chan, prev_role);
    return ret;
  }

  return LAGOPUS_RESULT_OK;
}
Esempio n. 7
0
lagopus_result_t
channel_mgr_channel_connection_status_get(const char *channel_name,
    datastore_channel_status_t *status) {
  lagopus_result_t ret;
  struct channel *chan;

  ret = channel_mgr_channel_lookup_by_name(channel_name, &chan);
  if (ret != LAGOPUS_RESULT_OK) {
    return ret;
  }

  if (channel_is_alive(chan)) {
    *status = DATASTORE_CHANNEL_CONNECTED;
  } else {
    *status = DATASTORE_CHANNEL_DISONNECTED;
  }

  return LAGOPUS_RESULT_OK;
}
Esempio n. 8
0
void
test_channel_mgr_apis(void) {
  lagopus_ip_address_t *addr4 = NULL, *laddr4 = NULL;
  struct channel *chan = NULL;
  lagopus_result_t ret;
  uint16_t sport;
  datastore_controller_role_t role;
  datastore_channel_status_t status;
  uint8_t version;

  lagopus_ip_address_create("127.0.0.1", true, &addr4);

  ret = channel_mgr_channel_create("channel1", addr4, 10032, addr4, 20032,
                                   DATASTORE_CHANNEL_PROTOCOL_TCP);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
  ret = channel_mgr_channel_lookup_by_name("channel1", &chan);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);

  ret = channel_mgr_controller_set("channel1", DATASTORE_CONTROLLER_ROLE_MASTER,
                                   DATASTORE_CONTROLLER_CONNECTION_TYPE_AUXILIARY);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);

  ret = channel_mgr_channel_local_port_get("channel1", &sport);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
  TEST_ASSERT_EQUAL(20032, sport);

  ret = channel_mgr_channel_local_addr_get("channel1", &laddr4);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
  TEST_ASSERT_EQUAL(true, lagopus_ip_address_equals(addr4, laddr4));

  ret = channel_mgr_channel_connection_status_get("channel1", &status);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
  TEST_ASSERT_EQUAL(DATASTORE_CHANNEL_DISONNECTED, status);

  ret = channel_mgr_channel_role_get("channel1", &role);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
  TEST_ASSERT_EQUAL(DATASTORE_CONTROLLER_ROLE_MASTER, role);

  ret = channel_mgr_ofp_version_get("channel1", &version);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);
  TEST_ASSERT_EQUAL(4, version);

  ret = channel_mgr_channel_dpid_set("channel1", (uint64_t) dpid);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);

  ret = channel_mgr_channel_dpid_unset("channel1");
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);

  ret = channel_mgr_channel_dpid_set("channel1", (uint64_t) dpid);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);

  ret = channel_mgr_channel_start("channel1");
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);

  ret = channel_mgr_channel_connection_status_get("channel1", &status);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);

  ret = channel_mgr_channel_dpid_unset("channel1");
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);

  ret = channel_mgr_channel_stop("channel1");
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);

  ret = channel_mgr_channel_destroy("channel1");
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_OK, ret);

  ret = channel_mgr_channel_lookup_by_name("channel1", &chan);
  TEST_ASSERT_EQUAL(LAGOPUS_RESULT_NOT_FOUND, ret);

  lagopus_ip_address_destroy(addr4);
  lagopus_ip_address_destroy(laddr4);
}