kubernetes-client/c
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[Configuration]Update the data structures for kube config file

Browse Source
This commit is contained in:
Hui Yu
2020-04-07 22:44:34 +08:00
parent 705a605e95
commit ed82ac046a
4 changed files with 196 additions and 445 deletions
Download Patch File Download Diff File Expand all files Collapse all files

95
kubernetes/config/kube_config.c
View File

@@ -2,23 +2,21 @@
#include "kube_config_yaml.h"
#include <errno.h>
#include <unistd.h>
#include <string.h>
#define ENV_KUBECONFIGE "KUBECONFIG"
#define ENV_KUBECONFIG "KUBECONFIG"
#define ENV_HOME "HOME"
#define KUBE_CONFIG_DEFAULT_LOCATION "%s/.kube/config"
#define KUBE_CONFIG_TEMPFILE_NAME_TEMPLATE "/tmp/kubeconfig-XXXXXX"
static int setBasePath(char **pBasePath, char *basePath)
{
int rc = 0;
char *_basePath = strdup(basePath);
if (_basePath) {
*pBasePath = _basePath;
} else {
rc = -1;
return 0;
}
return rc;
return -1;
}
static char *kubeconfig_mk_cert_key_tempfile(const char *b64data)
@@ -39,14 +37,13 @@ static char *kubeconfig_mk_cert_key_tempfile(const char *b64data)
return NULL;
}
if (-1 == write(fd, b64decode, decoded_bytes)) {
int rc = write(fd, b64decode, decoded_bytes);
close(fd);
if (-1 == rc) {
fprintf(stderr, "%s: Writing temp file failed with error [%s]\n", fname, strerror(errno));
close(fd);
return NULL;
}
close(fd);
return strdup(tempfile_name_template);
}
@@ -72,10 +69,9 @@ static void unsetSslConfig(sslConfig_t * sslConfig)
if (sslConfig->CACertFile) {
kubeconfig_rm_tempfile(sslConfig->CACertFile);
}
}
static int setSslConfig(sslConfig_t ** pSslConfig, kubeconfig_cluster_t * cluster, kubeconfig_user_t * user)
static int setSslConfig(sslConfig_t ** pSslConfig, const kubeconfig_property_t * cluster, const kubeconfig_property_t * user)
{
int rc = 0;
char *client_cert_file = NULL;
@@ -119,19 +115,17 @@ static int setSslConfig(sslConfig_t ** pSslConfig, kubeconfig_cluster_t * cluste
return rc;
}
static int setApiKeys(list_t ** pApiKeys, kubeconfig_user_t * user)
static int setApiKeys(list_t ** pApiKeys, const kubeconfig_property_t * user)
{
int rc = 0;
list_t *apiKeys = list_create();
if (apiKeys) {
/* under development for the token based authentication */
*pApiKeys = apiKeys;
} else {
rc = -1;
return 0;
}
return rc;
return -1;
}
static char *getWorkingConfigFile(const char *configFileNamePassedIn)
@@ -143,7 +137,7 @@ static char *getWorkingConfigFile(const char *configFileNamePassedIn)
if (configFileNamePassedIn) {
configFileName = strdup(configFileNamePassedIn);
} else {
kubeconfig_env = getenv(ENV_KUBECONFIGE);
kubeconfig_env = getenv(ENV_KUBECONFIG);
if (kubeconfig_env) {
configFileName = strdup(kubeconfig_env);
} else {
@@ -160,61 +154,22 @@ static char *getWorkingConfigFile(const char *configFileNamePassedIn)
return configFileName;
}
static kubeconfig_context_t *kubeconfig_get_current_context(kubeconfig_context_t ** contexts, int contexts_count, const char *current_context_str)
static const kubeconfig_property_t *kubeconfig_get_current_property(kubeconfig_property_t ** properties, int properties_count, const char *property_name)
{
kubeconfig_context_t *current_context = NULL;
const kubeconfig_property_t *current_property = NULL;
if (NULL == contexts || NULL == current_context_str) {
if (NULL == properties || NULL == property_name) {
return NULL;
}
int i = 0;
for (i = 0; i < contexts_count; i++) {
if (0 == strcmp(contexts[i]->name, current_context_str)) {
current_context = contexts[i];
for (int i = 0; i < properties_count; i++) {
if (0 == strcmp(properties[i]->name, property_name)) {
current_property = properties[i];
break;
}
}
return current_context;
}
static kubeconfig_cluster_t *kubeconfig_get_current_cluster(kubeconfig_cluster_t ** clusters, int clusters_count, const char *cluster_name)
{
kubeconfig_cluster_t *current_cluster = NULL;
if (NULL == clusters || NULL == cluster_name) {
return NULL;
}
int i = 0;
for (i = 0; i < clusters_count; i++) {
if (0 == strcmp(clusters[i]->name, cluster_name)) {
current_cluster = clusters[i];
break;
}
}
return current_cluster;
}
static kubeconfig_user_t *kubeconfig_get_current_user(kubeconfig_user_t ** users, int users_count, const char *user_name)
{
kubeconfig_user_t *current_user = NULL;
if (NULL == users || NULL == user_name) {
return NULL;
}
int i = 0;
for (i = 0; i < users_count; i++) {
if (0 == strcmp(users[i]->name, user_name)) {
current_user = users[i];
break;
}
}
return current_user;
return current_property;
}
int load_kube_config(char **pBasePath, sslConfig_t ** pSslConfig, list_t ** pApiKeys, const char *configFileName)
@@ -223,9 +178,9 @@ int load_kube_config(char **pBasePath, sslConfig_t ** pSslConfig, list_t ** pApi
int rc = 0;
kubeconfig_context_t *current_context = NULL;
kubeconfig_cluster_t *current_cluster = NULL;
kubeconfig_user_t *current_user = NULL;
const kubeconfig_property_t *current_context = NULL;
const kubeconfig_property_t *current_cluster = NULL;
const kubeconfig_property_t *current_user = NULL;
kubeconfig_t *kubeconfig = kubeconfig_create();
if (!kubeconfig) {
@@ -241,21 +196,21 @@ int load_kube_config(char **pBasePath, sslConfig_t ** pSslConfig, list_t ** pApi
goto end;
}
current_context = kubeconfig_get_current_context(kubeconfig->contexts, kubeconfig->contexts_count, kubeconfig->current_context);
current_context = kubeconfig_get_current_property(kubeconfig->contexts, kubeconfig->contexts_count, kubeconfig->current_context);
if (!current_context) {
fprintf(stderr, "%s: Cannot get the current context by the kubeconfig.\n", fname);
rc = -1;
goto end;
}
current_cluster = kubeconfig_get_current_cluster(kubeconfig->clusters, kubeconfig->clusters_count, current_context->cluster);
current_cluster = kubeconfig_get_current_property(kubeconfig->clusters, kubeconfig->clusters_count, current_context->cluster);
if (!current_cluster) {
fprintf(stderr, "%s: Cannot get the current cluster information by the kubeconfig.\n", fname);
rc = -1;
goto end;
}
current_user = kubeconfig_get_current_user(kubeconfig->users, kubeconfig->users_count, current_context->user);
current_user = kubeconfig_get_current_property(kubeconfig->users, kubeconfig->users_count, current_context->user);
if (!current_user) {
fprintf(stderr, "%s: Cannot get the current user information by the kubeconfig.\n", fname);
rc = -1;

223
kubernetes/config/kube_config_model.c
View File

@@ -15,24 +15,31 @@ void kubeconfig_auth_provider_free(kubeconfig_auth_provider_t * provider)
if (provider->name) {
free(provider->name);
provider->name = NULL;
}
if (provider->id_token) {
free(provider->id_token);
provider->id_token = NULL;
}
if (provider->cmd_path) {
free(provider->cmd_path);
provider->cmd_path = NULL;
}
if (provider->access_token) {
free(provider->access_token);
provider->access_token = NULL;
}
if (provider->expires_on) {
free(provider->expires_on);
provider->expires_on = NULL;
}
if (provider->expiry) {
free(provider->expiry);
provider->expiry = NULL;
}
if (provider->idp_certificate_authority_data) {
free(provider->idp_certificate_authority_data);
provider->idp_certificate_authority_data = NULL;
}
free(provider);
@@ -52,174 +59,105 @@ void kubeconfig_exec_free(kubeconfig_exec_t * exec)
if (exec->command) {
free(exec->command);
exec->command = NULL;
}
free(exec);
}
kubeconfig_cluster_t *kubeconfig_cluster_create()
kubeconfig_property_t *kubeconfig_property_create(kubeconfig_property_type_t type)
{
kubeconfig_cluster_t *cluster = calloc(1, sizeof(kubeconfig_cluster_t));
return cluster;
kubeconfig_property_t *property = calloc(1, sizeof(kubeconfig_property_t));
property->type = type;
return property;
}
void kubeconfig_cluster_free(kubeconfig_cluster_t * cluster)
void kubeconfig_property_free(kubeconfig_property_t * property)
{
if (!cluster) {
if (!property) {
return;
}
if (cluster->name) {
free(cluster->name);
}
if (cluster->server) {
free(cluster->server);
}
if (cluster->certificate_authority_data) {
free(cluster->certificate_authority_data);
if (property->name) {
free(property->name);
property->name = NULL;
}
free(cluster);
}
kubeconfig_cluster_t **kubeconfig_clusters_create(int clusters_count)
{
kubeconfig_cluster_t **clusters = (kubeconfig_cluster_t **) calloc(clusters_count, sizeof(kubeconfig_cluster_t *));
int i = 0;
for (i = 0; i < clusters_count; i++) {
clusters[i] = kubeconfig_cluster_create();
}
return clusters;
}
void kubeconfig_clusters_free(kubeconfig_cluster_t ** clusters, int cluster_count)
{
if (!clusters) {
return;
}
int i = 0;
for (i = 0; i < cluster_count; i++) {
if (clusters[i]) {
kubeconfig_cluster_free(clusters[i]);
clusters[i] = NULL;
if (KUBECONFIG_PROPERTY_TYPE_CLUSTER == property->type) {
if (property->server) {
free(property->server);
property->server = NULL;
}
if (property->certificate_authority_data) {
free(property->certificate_authority_data);
property->certificate_authority_data = NULL;
}
}
free(clusters);
}
kubeconfig_user_t *kubeconfig_user_create()
{
kubeconfig_user_t *user = calloc(1, sizeof(kubeconfig_user_t));
return user;
}
void kubeconfig_user_free(kubeconfig_user_t * user)
{
if (!user) {
return;
}
if (user->name) {
free(user->name);
}
if (user->client_certificate_data) {
free(user->client_certificate_data);
}
if (user->client_key_data) {
free(user->client_key_data);
}
if (user->username) {
free(user->username);
}
if (user->password) {
free(user->password);
}
if (user->auth_provider) {
kubeconfig_auth_provider_free(user->auth_provider);
}
if (user->exec) {
kubeconfig_exec_free(user->exec);
}
free(user);
}
kubeconfig_user_t **kubeconfig_users_create(int users_count)
{
kubeconfig_user_t **users = (kubeconfig_user_t **) calloc(users_count, sizeof(kubeconfig_user_t *));
int i = 0;
for (i = 0; i < users_count; i++) {
users[i] = kubeconfig_user_create();
}
return users;
}
void kubeconfig_users_free(kubeconfig_user_t ** users, int users_count)
{
if (!users) {
return;
}
int i = 0;
for (i = 0; i < users_count; i++) {
if (users[i]) {
kubeconfig_user_free(users[i]);
users[i] = NULL;
if (KUBECONFIG_PROPERTY_TYPE_USER == property->type) {
if (property->client_certificate_data) {
free(property->client_certificate_data);
property->client_certificate_data = NULL;
}
if (property->client_key_data) {
free(property->client_key_data);
property->client_key_data = NULL;
}
if (property->username) {
free(property->username);
property->username = NULL;
}
if (property->password) {
free(property->password);
property->password = NULL;
}
if (property->auth_provider) {
kubeconfig_auth_provider_free(property->auth_provider);
property->auth_provider = NULL;
}
if (property->exec) {
kubeconfig_exec_free(property->exec);
property->exec = NULL;
}
}
free(users);
if (KUBECONFIG_PROPERTY_TYPE_CONTEXT == property->type) {
if (property->cluster) {
free(property->cluster);
property->cluster = NULL;
}
if (property->user) {
free(property->user);
property->user = NULL;
}
}
free(property);
}
kubeconfig_context_t *kubeconfig_context_create()
kubeconfig_property_t **kubeconfig_properties_create(int contexts_count, kubeconfig_property_type_t type)
{
kubeconfig_context_t *context = calloc(1, sizeof(kubeconfig_context_t));
return context;
}
void kubeconfig_context_free(kubeconfig_context_t * context)
{
if (!context) {
return;
}
if (context->name) {
free(context->name);
}
if (context->cluster) {
free(context->cluster);
}
if (context->user) {
free(context->user);
}
free(context);
}
kubeconfig_context_t **kubeconfig_contexts_create(int contexts_count)
{
kubeconfig_context_t **contexts = (kubeconfig_context_t **) calloc(contexts_count, sizeof(kubeconfig_context_t *));
kubeconfig_property_t **properties = (kubeconfig_property_t **) calloc(contexts_count, sizeof(kubeconfig_property_t *));
int i = 0;
for (i = 0; i < contexts_count; i++) {
contexts[i] = kubeconfig_context_create();
properties[i] = kubeconfig_property_create(type);
}
return contexts;
return properties;
}
void kubeconfig_contexts_free(kubeconfig_context_t ** contexts, int context_count)
void kubeconfig_properties_free(kubeconfig_property_t ** properties, int properties_count)
{
if (!contexts) {
if (!properties) {
return;
}
int i = 0;
for (i = 0; i < context_count; i++) {
if (contexts[i]) {
kubeconfig_context_free(contexts[i]);
contexts[i] = NULL;
for (int i = 0; i < properties_count; i++) {
if (properties[i]) {
kubeconfig_property_free(properties[i]);
properties[i] = NULL;
}
}
free(contexts);
free(properties);
}
kubeconfig_t *kubeconfig_create()
@@ -236,29 +174,36 @@ void kubeconfig_free(kubeconfig_t * kubeconfig)
if (kubeconfig->fileName) {
free(kubeconfig->fileName);
kubeconfig->fileName = NULL;
}
if (kubeconfig->apiVersion) {
free(kubeconfig->apiVersion);
kubeconfig->apiVersion = NULL;
}
if (kubeconfig->kind) {
free(kubeconfig->kind);
kubeconfig->kind = NULL;
}
if (kubeconfig->preferences) {
free(kubeconfig->preferences);
kubeconfig->preferences = NULL;
}
if (kubeconfig->current_context) {
free(kubeconfig->current_context);
kubeconfig->current_context = NULL;
}
if (kubeconfig->clusters) {
kubeconfig_clusters_free(kubeconfig->clusters, kubeconfig->clusters_count);
kubeconfig_properties_free(kubeconfig->clusters, kubeconfig->clusters_count);
kubeconfig->clusters = NULL;
}
if (kubeconfig->users) {
kubeconfig_users_free(kubeconfig->users, kubeconfig->users_count);
kubeconfig_properties_free(kubeconfig->users, kubeconfig->users_count);
kubeconfig->users = NULL;
}
if (kubeconfig->contexts) {
kubeconfig_contexts_free(kubeconfig->contexts, kubeconfig->contexts_count);
kubeconfig_properties_free(kubeconfig->contexts, kubeconfig->contexts_count);
kubeconfig->contexts = NULL;
}
free(kubeconfig);
}

95
kubernetes/config/kube_config_model.h
View File

@@ -5,12 +5,6 @@
extern "C" {
#endif
typedef struct kubeconfig_cluster_t {
char *name;
char *server;
char *certificate_authority_data;
} kubeconfig_cluster_t ;
typedef struct kubeconfig_auth_provider_t {
char *name;
char *id_token;
@@ -19,28 +13,41 @@ typedef struct kubeconfig_auth_provider_t {
char *expires_on;
char *expiry;
char *idp_certificate_authority_data;
} kubeconfig_auth_provider_t ;
} kubeconfig_auth_provider_t;
typedef struct kubeconfig_exec_t {
char *command;
} kubeconfig_exec_t;
typedef struct kubeconfig_user_t {
char *name;
char *client_certificate_data;
char *client_key_data;
kubeconfig_auth_provider_t *auth_provider;
kubeconfig_exec_t *exec;
int insecure_skip_tls_verify;
char *username;
char *password;
} kubeconfig_user_t;
typedef enum kubeconfig_property_type_t {
KUBECONFIG_PROPERTY_TYPE_CONTEXT = 1,
KUBECONFIG_PROPERTY_TYPE_CLUSTER,
KUBECONFIG_PROPERTY_TYPE_USER
} kubeconfig_property_type_t;
typedef struct kubeconfig_context_t {
typedef struct kubeconfig_property_t {
kubeconfig_property_type_t type;
char *name;
char *cluster;
char *user;
} kubeconfig_context_t ;
union {
struct { /* context */
char *cluster;
char *user;
};
struct { /* cluster */
char *server;
char *certificate_authority_data;
};
struct { /* user */
char *client_certificate_data;
char *client_key_data;
kubeconfig_auth_provider_t *auth_provider;
kubeconfig_exec_t *exec;
int insecure_skip_tls_verify;
char *username;
char *password;
};
};
} kubeconfig_property_t;
typedef struct kubeconfig_t {
char *fileName;
@@ -48,42 +55,30 @@ typedef struct kubeconfig_t {
char *preferences;
char *kind;
char *current_context;
kubeconfig_context_t **contexts;
int contexts_count;
kubeconfig_cluster_t **clusters;
int clusters_count;
kubeconfig_user_t **users;
int users_count;
kubeconfig_property_t **contexts;
int contexts_count;
kubeconfig_property_t **clusters;
int clusters_count;
kubeconfig_property_t **users;
int users_count;
} kubeconfig_t;
kubeconfig_auth_provider_t *kubeconfig_auth_provider_create();
void kubeconfig_auth_provider_free(kubeconfig_auth_provider_t * provider);
kubeconfig_auth_provider_t * kubeconfig_auth_provider_create();
void kubeconfig_auth_provider_free(kubeconfig_auth_provider_t *provider);
kubeconfig_exec_t *kubeconfig_exec_create();
void kubeconfig_exec_free(kubeconfig_exec_t * exec);
kubeconfig_exec_t * kubeconfig_exec_create();
void kubeconfig_exec_free(kubeconfig_exec_t *exec);
kubeconfig_property_t *kubeconfig_property_create(kubeconfig_property_type_t type);
void kubeconfig_property_free(kubeconfig_property_t * property);
kubeconfig_cluster_t * kubeconfig_cluster_create();
void kubeconfig_cluster_free(kubeconfig_cluster_t *cluster);
kubeconfig_cluster_t ** kubeconfig_clusters_create(int clusters_count);
void kubeconfig_clusters_free(kubeconfig_cluster_t **clusters, int clusters_count);
kubeconfig_property_t **kubeconfig_properties_create(int contexts_count, kubeconfig_property_type_t type);
void kubeconfig_properties_free(kubeconfig_property_t ** properties, int properties_count);
kubeconfig_user_t * kubeconfig_user_create();
void kubeconfig_user_free(kubeconfig_user_t *user);
kubeconfig_user_t ** kubeconfig_users_create(int users_count);
void kubeconfig_users_free(kubeconfig_user_t **users, int users_count);
kubeconfig_context_t * kubeconfig_context_create();
void kubeconfig_context_free(kubeconfig_context_t *context);
kubeconfig_context_t ** kubeconfig_contexts_create(int contexts_count);
void kubeconfig_contexts_free(kubeconfig_context_t **contexts, int contexts_count);
kubeconfig_t * kubeconfig_create();
void kubeconfig_free(kubeconfig_t *kubeconfig);
kubeconfig_t *kubeconfig_create();
void kubeconfig_free(kubeconfig_t * kubeconfig);
#ifdef __cplusplus
}
#endif
#endif /* _KUBE_CONFIG_MODEL_H */
#endif /* _KUBE_CONFIG_MODEL_H */

228
kubernetes/config/kube_config_yaml.c
View File

@@ -26,9 +26,9 @@ mapping :: = MAPPING - START(node node) * MAPPING - END
#define KEY_CLIENT_CERTIFICATE_DATA "client-certificate-data"
#define KEY_CLIENT_KEY_DATA "client-key-data"
static int parse_kubeconfig_yaml_userinfo_mapping(kubeconfig_user_t * user, yaml_document_t * document, yaml_node_t * node)
static int parse_kubeconfig_yaml_property_info_mapping(kubeconfig_property_t * property, yaml_document_t * document, yaml_node_t * node)
{
static char fname[] = "parse_kubeconfig_yaml_userinfo_mapping()";
static char fname[] = "parse_kubeconfig_yaml_property_info_mapping()";
yaml_node_pair_t *pair = NULL;
yaml_node_t *key = NULL;
@@ -44,10 +44,24 @@ static int parse_kubeconfig_yaml_userinfo_mapping(kubeconfig_user_t * user, yaml
}
if (value->type == YAML_SCALAR_NODE) {
if (0 == strcmp(key->data.scalar.value, KEY_CLIENT_CERTIFICATE_DATA)) {
user->client_certificate_data = strdup(value->data.scalar.value);
} else if (0 == strcmp(key->data.scalar.value, KEY_CLIENT_KEY_DATA)) {
user->client_key_data = strdup(value->data.scalar.value);
if (KUBECONFIG_PROPERTY_TYPE_CLUSTER == property->type) {
if (0 == strcmp(key->data.scalar.value, KEY_CERTIFICATE_AUTHORITY_DATA)) {
property->certificate_authority_data = strdup(value->data.scalar.value);
} else if (0 == strcmp(key->data.scalar.value, KEY_SERVER)) {
property->server = strdup(value->data.scalar.value);
}
} else if (KUBECONFIG_PROPERTY_TYPE_USER == property->type) {
if (0 == strcmp(key->data.scalar.value, KEY_CLIENT_CERTIFICATE_DATA)) {
property->client_certificate_data = strdup(value->data.scalar.value);
} else if (0 == strcmp(key->data.scalar.value, KEY_CLIENT_KEY_DATA)) {
property->client_key_data = strdup(value->data.scalar.value);
}
} else if (KUBECONFIG_PROPERTY_TYPE_CONTEXT == property->type) {
if (0 == strcmp(key->data.scalar.value, KEY_CLUSTER)) {
property->cluster = strdup(value->data.scalar.value);
} else if (0 == strcmp(key->data.scalar.value, KEY_USER)) {
property->user = strdup(value->data.scalar.value);
}
}
}
}
@@ -55,9 +69,9 @@ static int parse_kubeconfig_yaml_userinfo_mapping(kubeconfig_user_t * user, yaml
return 0;
}
static int parse_kubeconfig_yaml_user_mapping(kubeconfig_user_t * user, yaml_document_t * document, yaml_node_t * node)
static int parse_kubeconfig_yaml_property_mapping(kubeconfig_property_t * property, yaml_document_t * document, yaml_node_t * node)
{
static char fname[] = "parse_kubeconfig_yaml_user_mapping()";
static char fname[] = "parse_kubeconfig_yaml_property_mapping()";
int rc = 0;
yaml_node_pair_t *pair = NULL;
@@ -75,207 +89,49 @@ static int parse_kubeconfig_yaml_user_mapping(kubeconfig_user_t * user, yaml_doc
if (value->type == YAML_SCALAR_NODE) {
if (0 == strcmp(key->data.scalar.value, KEY_NAME)) {
user->name = strdup(value->data.scalar.value);
property->name = strdup(value->data.scalar.value);
}
} else if (value->type == YAML_MAPPING_NODE) {
rc = parse_kubeconfig_yaml_userinfo_mapping(user, document, value);
rc = parse_kubeconfig_yaml_property_info_mapping(property, document, value);
}
}
return rc;
}
static int parse_kubeconfig_yaml_users_sequence(kubeconfig_t * kubeconfig, yaml_document_t * document, yaml_node_t * node)
static int parse_kubeconfig_yaml_sequence(kubeconfig_property_t *** p_properties, int *p_properties_count, kubeconfig_property_type_t type, yaml_document_t * document, yaml_node_t * node)
{
int rc = 0;
yaml_node_item_t *item = NULL;
yaml_node_t *value = NULL;
int item_count = 0;
int i = 0;
int rc = 0;
// Get the count of users
// Get the count of data (e.g. cluster, context, user)
for (item = node->data.sequence.items.start, item_count = 0; item < node->data.sequence.items.top; item++, item_count++) {
;
}
kubeconfig->users_count = item_count;
kubeconfig->users = kubeconfig_users_create(kubeconfig->users_count);
int properties_count = item_count;
kubeconfig_property_t **properties = kubeconfig_properties_create(properties_count, type);
if (!properties) {
fprintf(stderr, "Cannot allocate memory for kubeconfig properties.\n");
return -1;
}
for (item = node->data.sequence.items.start, i = 0; item < node->data.sequence.items.top; item++, i++) {
value = yaml_document_get_node(document, *item);
rc = parse_kubeconfig_yaml_user_mapping(kubeconfig->users[i], document, value);
}
return rc;
}
static int parse_kubeconfig_yaml_contextinfo_mapping(kubeconfig_context_t * context, yaml_document_t * document, yaml_node_t * node)
{
static char fname[] = "parse_kubeconfig_yaml_contextinfo_mapping()";
yaml_node_pair_t *pair = NULL;
yaml_node_t *key = NULL;
yaml_node_t *value = NULL;
for (pair = node->data.mapping.pairs.start; pair < node->data.mapping.pairs.top; pair++) {
key = yaml_document_get_node(document, pair->key);
value = yaml_document_get_node(document, pair->value);
if (key->type != YAML_SCALAR_NODE) {
fprintf(stderr, "%s: The key node is not YAML_SCALAR_NODE.\n", fname);
rc = parse_kubeconfig_yaml_property_mapping(properties[i], document, value);
if (0 != rc) {
fprintf(stderr, "Cannot parse kubeconfi properties.\n");
return -1;
}
if (value->type == YAML_SCALAR_NODE) {
if (0 == strcmp(key->data.scalar.value, KEY_CLUSTER)) {
context->cluster = strdup(value->data.scalar.value);
} else if (0 == strcmp(key->data.scalar.value, KEY_USER)) {
context->user = strdup(value->data.scalar.value);
}
}
}
*p_properties = properties;
*p_properties_count = properties_count;
return 0;
}
static int parse_kubeconfig_yaml_context_mapping(kubeconfig_context_t * context, yaml_document_t * document, yaml_node_t * node)
{
static char fname[] = "parse_kubeconfig_yaml_context_mapping()";
int rc = 0;
yaml_node_pair_t *pair = NULL;
yaml_node_t *key = NULL;
yaml_node_t *value = NULL;
for (pair = node->data.mapping.pairs.start; pair < node->data.mapping.pairs.top; pair++) {
key = yaml_document_get_node(document, pair->key);
value = yaml_document_get_node(document, pair->value);
if (key->type != YAML_SCALAR_NODE) {
fprintf(stderr, "%s: The key node is not YAML_SCALAR_NODE.\n", fname);
return -1;
}
if (value->type == YAML_SCALAR_NODE) {
if (0 == strcmp(key->data.scalar.value, KEY_NAME)) {
context->name = strdup(value->data.scalar.value);
}
} else if (value->type == YAML_MAPPING_NODE) {
rc = parse_kubeconfig_yaml_contextinfo_mapping(context, document, value);
}
}
return rc;
}
static int parse_kubeconfig_yaml_contexts_sequence(kubeconfig_t * kubeconfig, yaml_document_t * document, yaml_node_t * node)
{
int rc = 0;
yaml_node_item_t *item = NULL;
yaml_node_t *value = NULL;
int item_count = 0;
int i = 0;
// Get the count of contexts
for (item = node->data.sequence.items.start, item_count = 0; item < node->data.sequence.items.top; item++, item_count++) {
;
}
kubeconfig->contexts_count = item_count;
kubeconfig->contexts = kubeconfig_contexts_create(kubeconfig->contexts_count);
for (item = node->data.sequence.items.start, i = 0; item < node->data.sequence.items.top; item++, i++) {
value = yaml_document_get_node(document, *item);
rc = parse_kubeconfig_yaml_context_mapping(kubeconfig->contexts[i], document, value);
}
return rc;
}
static int parse_kubeconfig_yaml_clusterinfo_mapping(kubeconfig_cluster_t * cluster, yaml_document_t * document, yaml_node_t * node)
{
static char fname[] = "parse_kubeconfig_yaml_clusterinfo_mapping()";
yaml_node_pair_t *pair = NULL;
yaml_node_t *key = NULL;
yaml_node_t *value = NULL;
for (pair = node->data.mapping.pairs.start; pair < node->data.mapping.pairs.top; pair++) {
key = yaml_document_get_node(document, pair->key);
value = yaml_document_get_node(document, pair->value);
if (key->type != YAML_SCALAR_NODE) {
fprintf(stderr, "%s: The key node is not YAML_SCALAR_NODE.\n", fname);
return -1;
}
if (value->type == YAML_SCALAR_NODE) {
if (0 == strcmp(key->data.scalar.value, KEY_CERTIFICATE_AUTHORITY_DATA)) {
cluster->certificate_authority_data = strdup(value->data.scalar.value);
} else if (0 == strcmp(key->data.scalar.value, KEY_SERVER)) {
cluster->server = strdup(value->data.scalar.value);
}
}
}
return 0;
}
static int parse_kubeconfig_yaml_cluster_mapping(kubeconfig_cluster_t * cluster, yaml_document_t * document, yaml_node_t * node)
{
static char fname[] = "parse_kubeconfig_yaml_cluster_mapping()";
int rc = 0;
yaml_node_pair_t *pair = NULL;
yaml_node_t *key = NULL;
yaml_node_t *value = NULL;
for (pair = node->data.mapping.pairs.start; pair < node->data.mapping.pairs.top; pair++) {
key = yaml_document_get_node(document, pair->key);
value = yaml_document_get_node(document, pair->value);
if (key->type != YAML_SCALAR_NODE) {
fprintf(stderr, "%s: The key node is not YAML_SCALAR_NODE.\n", fname);
return -1;
}
if (value->type == YAML_SCALAR_NODE) {
if (0 == strcmp(key->data.scalar.value, KEY_NAME)) {
cluster->name = strdup(value->data.scalar.value);
}
} else if (value->type == YAML_MAPPING_NODE) {
rc = parse_kubeconfig_yaml_clusterinfo_mapping(cluster, document, value);
}
}
return rc;
}
static int parse_kubeconfig_yaml_clusters_sequence(kubeconfig_t * kubeconfig, yaml_document_t * document, yaml_node_t * node)
{
int rc = 0;
yaml_node_item_t *item = NULL;
yaml_node_t *value = NULL;
int item_count = 0;
int i = 0;
// Get the count of clusters
for (item = node->data.sequence.items.start, item_count = 0; item < node->data.sequence.items.top; item++, item_count++) {
;
}
kubeconfig->clusters_count = item_count;
kubeconfig->clusters = kubeconfig_clusters_create(kubeconfig->clusters_count);
for (item = node->data.sequence.items.start, i = 0; item < node->data.sequence.items.top; item++, i++) {
value = yaml_document_get_node(document, *item);
rc = parse_kubeconfig_yaml_cluster_mapping(kubeconfig->clusters[i], document, value);
}
return rc;
}
@@ -307,11 +163,11 @@ static int parse_kubeconfig_yaml_top_mapping(kubeconfig_t * kubeconfig, yaml_doc
}
} else {
if (0 == strcmp(key->data.scalar.value, KEY_CLUSTERS)) {
rc = parse_kubeconfig_yaml_clusters_sequence(kubeconfig, document, value);
rc = parse_kubeconfig_yaml_sequence(&(kubeconfig->clusters), &(kubeconfig->clusters_count), KUBECONFIG_PROPERTY_TYPE_CLUSTER, document, value);
} else if (0 == strcmp(key->data.scalar.value, KEY_CONTEXTS)) {
rc = parse_kubeconfig_yaml_contexts_sequence(kubeconfig, document, value);
rc = parse_kubeconfig_yaml_sequence(&(kubeconfig->contexts), &(kubeconfig->contexts_count), KUBECONFIG_PROPERTY_TYPE_CONTEXT, document, value);
} else if (0 == strcmp(key->data.scalar.value, KEY_USERS)) {
rc = parse_kubeconfig_yaml_users_sequence(kubeconfig, document, value);
rc = parse_kubeconfig_yaml_sequence(&(kubeconfig->users), &(kubeconfig->users_count), KUBECONFIG_PROPERTY_TYPE_USER, document, value);
}
}
}