Applications
/
ubl-settings-resourcequota
7
0
Fork 2
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Исправил парсер конфига

Browse Source
pull/4/head
Igor Belitskiy 2 years ago
parent 0c77eb11c4
commit ab4cc2f3a5
8 changed files with 317 additions and 168 deletions
Show Stats Download Patch File Download Diff File

240
source/philos_utils.c
Unescape View File

@ -390,20 +390,20 @@ char** philos_pars_terminal_systemd_cgls(char* CMD_GET_SLICE_SERVICE, char* str_
}
return array_data;
}
char* philos_pard_array_add_cmd(char* cmd, temp_config* _config, char* key, int* array_io, int* array_io_pow_size) {
char* philos_pard_array_add_cmd(char* cmd, temp_config* _config, char* key, int* array_io, int* array_io_pow_size, char** disk, int size) {
char* split_simvol = g_malloc0(sizeof(char)*2);
int flag_format = 0;
char* cmd_old = yon_char_new(cmd);
char* cmd_new = "";
if (_config->disk && _config->size && array_io && array_io_pow_size) {
if (disk && size && array_io && array_io_pow_size) {
int index_find = 0;
for (int index = 0; index < _config->size; index++) {
for (int index = 0; index < size; index++) {
if (array_io_pow_size[index] >= 0 && array_io[index]>= 0) {
char* num_and_pow_size = philos_format_cfg_str_size_memory(" ", array_io[index], array_io_pow_size[index]);
if (!strstr(num_and_pow_size, "-")) {
cmd_new = yon_char_unite(cmd_new,
split_simvol,
_config->disk[index],
disk[index],
num_and_pow_size, NULL);
split_simvol[0] = ',';
split_simvol[1] = '\0';
@ -431,12 +431,12 @@ char* philos_pard_array_add_cmd(char* cmd, temp_config* _config, char* key, int*
}
}
int philos_check_activ_disk(temp_set_window *widgets, temp_config* _config) {
int philos_check_activ_disk(temp_set_window *widgets, temp_config* _config, int flag_check_array) {
char* disk = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->cbtTempDevice));
disk = yon_char_divide_search(disk," ", -1);
int bool_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead));
int bool_write = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite));
if (disk == NULL || _config->size == 0) {
if (disk == NULL || (_config->size_read == 0 && flag_check_array == 0) && (_config->size_write == 0 && flag_check_array==1)) {
return 0;
}
return 1;
@ -483,28 +483,43 @@ void philos_temp_generate_cmd(temp_set_window *widgets, temp_config* _config) {
split_simvol[1] = '\0';
}
if (gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempDevice))!=-1) {
if (_config->size!=0) {
str_cmd = philos_pard_array_add_cmd(str_cmd, _config, "IOReadBandwidthMax=", _config->i_o_limit_read, _config->i_o_limit_read_size);
str_cmd = philos_pard_array_add_cmd(str_cmd, _config, "IOWriteBandwidthMax=", _config->i_o_limit_write, _config->i_o_limit_write_size);
if (_config->size_read!=0) {
str_cmd = philos_pard_array_add_cmd(str_cmd, _config, "IOReadBandwidthMax=", _config->i_o_limit_read, _config->i_o_limit_read_size, _config->disk_read, _config->size_read);
}
else if (_config->size_write!=0) {
str_cmd = philos_pard_array_add_cmd(str_cmd, _config, "IOWriteBandwidthMax=", _config->i_o_limit_write, _config->i_o_limit_write_size, _config->disk_write, _config->size_write);
}
}
gtk_entry_set_text(GTK_ENTRY(widgets->entryTempCmd), str_cmd);
free(split_simvol);
}
void philos_temp_del_disk(temp_set_window *widgets, temp_config* _config) {
// flag_check_array = 0 READ
// flag_check_array = 1 WRITE
void philos_temp_del_disk(temp_set_window *widgets, temp_config* _config, int flag_check_array) {
char* disk = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->cbtTempDevice));
disk = yon_char_divide_search(disk, " ", -1);
int bool_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead));
int bool_write = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite));
if (philos_check_activ_disk(widgets, _config) == 0) {
char** ptr_disk = NULL;
int size = -1;
if (flag_check_array == 0) {
ptr_disk = _config->disk_read;
size = _config->size_read;
}
else if (flag_check_array == 1) {
ptr_disk = _config->disk_write;
size = _config->size_write;
}
if (philos_check_activ_disk(widgets, _config, flag_check_array) == 0) {
return;
}
if (_config->size) {
if (size) {
int index_find = -1;
if (_config->disk) {
for (int index = 0; index < _config->size; index++) {
char* disk_cfg = _config->disk[index];
if (ptr_disk) {
for (int index = 0; index < size; index++) {
char* disk_cfg = ptr_disk[index];
if (disk_cfg) {
if (strstr(disk_cfg, disk) != NULL) {
index_find = index;
@ -515,33 +530,50 @@ void philos_temp_del_disk(temp_set_window *widgets, temp_config* _config) {
}
if ((bool_read == 0 && bool_write == 0 && index_find != -1)) {
_config->disk = yon_char_parsed_shrink(_config->disk,&_config->size, index_find);
_config->size++;
_config->i_o_limit_read_size = remove_element_int_array(_config->i_o_limit_read_size,&_config->size, index_find);
_config->size++;
_config->i_o_limit_write_size = remove_element_int_array(_config->i_o_limit_write_size,&_config->size, index_find);
_config->size++;
_config->i_o_limit_read = remove_element_int_array(_config->i_o_limit_read,&_config->size, index_find);
_config->size++;
_config->i_o_limit_write = remove_element_int_array(_config->i_o_limit_write,&_config->size, index_find);
ptr_disk = yon_char_parsed_shrink(ptr_disk,&size, index_find);
size++;
_config->i_o_limit_read_size = remove_element_int_array(_config->i_o_limit_read_size,&size, index_find);
size++;
_config->i_o_limit_write_size = remove_element_int_array(_config->i_o_limit_write_size,&size, index_find);
size++;
_config->i_o_limit_read = remove_element_int_array(_config->i_o_limit_read,&size, index_find);
size++;
_config->i_o_limit_write = remove_element_int_array(_config->i_o_limit_write,&size, index_find);
}
}
if (flag_check_array == 0) {
if (ptr_disk) {
_config->disk_read = ptr_disk;
_config->size_read = size;
}
}
else if (flag_check_array == 1) {
if (ptr_disk) {
_config->disk_write = ptr_disk;
_config->size_write = size;
}
}
}
void philos_temp_config_init(temp_config* _config) {
if (_config->size != 0) {
philos_free_string_array(&_config->disk, _config->size);
philos_free_int_array(&_config->i_o_limit_read, _config->size);
philos_free_int_array(&_config->i_o_limit_read_size, _config->size);
philos_free_int_array(&_config->i_o_limit_write, _config->size);
philos_free_int_array(&_config->i_o_limit_write_size, _config->size);
}
_config->disk = NULL;
if (_config->size_read != 0) {
philos_free_string_array(&_config->disk_read, _config->size_read);
philos_free_int_array(&_config->i_o_limit_read, _config->size_read);
philos_free_int_array(&_config->i_o_limit_read_size, _config->size_read);
}
else if (_config->size_write != 0) {
philos_free_string_array(&_config->disk_write, _config->size_write);
philos_free_int_array(&_config->i_o_limit_write, _config->size_write);
philos_free_int_array(&_config->i_o_limit_write_size, _config->size_write);
}
_config->disk_read = NULL;
_config->disk_write = NULL;
_config->i_o_limit_read = NULL;
_config->i_o_limit_write = NULL;
_config->i_o_limit_read_size = NULL;
_config->i_o_limit_write_size = NULL;
_config->size = 0;
_config->size_read = 0;
_config->size_write = 0;
}
// flag_check_array = 0 READ
@ -552,17 +584,33 @@ void philos_update_device_to_entry(temp_set_window *widgets, temp_config* _confi
disk = yon_char_divide_search(disk, " ", -1);
if (disk_id != -1) {
int index_find = -1;
if (_config->disk) {
for (int index = 0; index < _config->size; index++) {
char* disk_cfg = _config->disk[index];
if (disk_cfg) {
if (strstr(disk_cfg, disk) != NULL) {
index_find = index;
break;
if (flag_check_array == 0) {
if (_config->disk_read) {
for (int index = 0; index < _config->size_read; index++) {
char* disk_cfg = _config->disk_read[index];
if (disk_cfg) {
if (strstr(disk_cfg, disk) != NULL) {
index_find = index;
break;
}
}
}
}
}
else if (flag_check_array == 1) {
if (_config->disk_write) {
for (int index = 0; index < _config->size_write; index++) {
char* disk_cfg = _config->disk_write[index];
if (disk_cfg) {
if (strstr(disk_cfg, disk) != NULL) {
index_find = index;
break;
}
}
}
}
}
if (index_find != -1) {
if (flag_check_array==0) {
@ -617,18 +665,29 @@ void philos_update_device_to_entry(temp_set_window *widgets, temp_config* _confi
gtk_combo_box_set_active(GTK_COMBO_BOX(widgets->cbtTempRead), 0);
}
}
void philos_temp_add_disk(temp_set_window *widgets, temp_config* _config) {
// flag_check_array = 0 READ
// flag_check_array = 1 WRITE
void philos_temp_add_disk(temp_set_window *widgets, temp_config* _config, int flag_check_array) {
char* disk = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(widgets->cbtTempDevice));
disk = yon_char_divide_search(disk, " ", -1);
int disk_id = gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempDevice));
int bool_read = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead));
int bool_write = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite));
if (disk_id >= 0 && _config->size !=0) {
char** ptr_disk = NULL;
int size = -1;
if (flag_check_array == 0) {
ptr_disk = _config->disk_read;
size = _config->size_read;
}
else if (flag_check_array == 1) {
ptr_disk = _config->disk_write;
size = _config->size_write;
}
if (disk_id >= 0 && size !=0) {
int index_find = -1;
if (_config->disk){
for (int index = 0; index < _config->size; index++) {
char* disk_cfg = _config->disk[index];
if (ptr_disk){
for (int index = 0; index < size; index++) {
char* disk_cfg = ptr_disk[index];
if (disk_cfg) {
if (strstr(disk_cfg, disk) != NULL) {
index_find = index;
@ -640,33 +699,33 @@ void philos_temp_add_disk(temp_set_window *widgets, temp_config* _config) {
if (index_find == -1) {
// Добавление
_config->disk = yon_char_parsed_append(_config->disk,&_config->size, disk);
_config->size--;
ptr_disk = yon_char_parsed_append(ptr_disk,&size, disk);
size--;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead))) {
_config->i_o_limit_read_size = philos_int_append(_config->i_o_limit_read_size,&_config->size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempRead)));
_config->size--;
_config->i_o_limit_read = philos_int_append(_config->i_o_limit_read,&_config->size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempRead)));
_config->size--;
_config->i_o_limit_read_size = philos_int_append(_config->i_o_limit_read_size,&size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempRead)));
size--;
_config->i_o_limit_read = philos_int_append(_config->i_o_limit_read,&size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempRead)));
size--;
}
else {
_config->i_o_limit_read_size = philos_int_append(_config->i_o_limit_read_size,&_config->size,-3);
_config->size--;
_config->i_o_limit_read = philos_int_append(_config->i_o_limit_read,&_config->size,-3);
_config->size--;
_config->i_o_limit_read_size = philos_int_append(_config->i_o_limit_read_size,&size,-3);
size--;
_config->i_o_limit_read = philos_int_append(_config->i_o_limit_read,&size,-3);
size--;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite))) {
_config->i_o_limit_write_size = philos_int_append(_config->i_o_limit_write_size,&_config->size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempWrite)));
_config->size--;
_config->i_o_limit_write = philos_int_append(_config->i_o_limit_write,&_config->size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempWrite)));
_config->size--;
_config->i_o_limit_write_size = philos_int_append(_config->i_o_limit_write_size,&size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempWrite)));
size--;
_config->i_o_limit_write = philos_int_append(_config->i_o_limit_write,&size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempWrite)));
size--;
}
else {
_config->i_o_limit_write_size = philos_int_append(_config->i_o_limit_write_size,&_config->size,-3);
_config->size--;
_config->i_o_limit_write = philos_int_append(_config->i_o_limit_write,&_config->size,-3);
_config->size--;
_config->i_o_limit_write_size = philos_int_append(_config->i_o_limit_write_size,&size,-3);
size--;
_config->i_o_limit_write = philos_int_append(_config->i_o_limit_write,&size,-3);
size--;
}
_config->size++;
size--;
}
else {
@ -692,37 +751,50 @@ void philos_temp_add_disk(temp_set_window *widgets, temp_config* _config) {
}
else {
if (bool_read == 1 || bool_write == 1) {
_config->disk = yon_char_parsed_append(_config->disk,&_config->size, disk);
_config->size--;
ptr_disk = yon_char_parsed_append(ptr_disk,&size, disk);
size--;
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempRead))) {
_config->i_o_limit_read_size = philos_int_append(_config->i_o_limit_read_size,&_config->size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempRead)));
_config->size--;
_config->i_o_limit_read = philos_int_append(_config->i_o_limit_read,&_config->size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempRead)));
_config->size--;
_config->i_o_limit_read_size = philos_int_append(_config->i_o_limit_read_size,&size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempRead)));
size--;
_config->i_o_limit_read = philos_int_append(_config->i_o_limit_read,&size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempRead)));
size--;
}
else {
_config->i_o_limit_read_size = philos_int_append(_config->i_o_limit_read_size,&_config->size,-3);
_config->size--;
_config->i_o_limit_read = philos_int_append(_config->i_o_limit_read,&_config->size,-3);
_config->size--;
_config->i_o_limit_read_size = philos_int_append(_config->i_o_limit_read_size,&size,-3);
size--;
_config->i_o_limit_read = philos_int_append(_config->i_o_limit_read,&size,-3);
size--;
}
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widgets->chbTempWrite))) {
_config->i_o_limit_write_size = philos_int_append(_config->i_o_limit_write_size,&_config->size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempWrite)));
_config->size--;
_config->i_o_limit_write = philos_int_append(_config->i_o_limit_write,&_config->size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempWrite)));
_config->size--;
_config->i_o_limit_write_size = philos_int_append(_config->i_o_limit_write_size,&size,(int)gtk_combo_box_get_active(GTK_COMBO_BOX(widgets->cbtTempWrite)));
size--;
_config->i_o_limit_write = philos_int_append(_config->i_o_limit_write,&size,gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(widgets->spinTempWrite)));
size--;
}
else {
_config->i_o_limit_write_size = philos_int_append(_config->i_o_limit_write_size,&_config->size,-3);
_config->size--;
_config->i_o_limit_write = philos_int_append(_config->i_o_limit_write,&_config->size,-3);
_config->size--;
_config->i_o_limit_write_size = philos_int_append(_config->i_o_limit_write_size,&size,-3);
size--;
_config->i_o_limit_write = philos_int_append(_config->i_o_limit_write,&size,-3);
size--;
}
_config->size++;
size++;
}
else {
}
}
if (flag_check_array == 0) {
if (ptr_disk) {
_config->disk_read = ptr_disk;
_config->size_read = size;
}
}
else if (flag_check_array == 1) {
if (ptr_disk) {
_config->disk_write = ptr_disk;
_config->size_write = size;
}
}
}
int* philos_int_append(int* array, int* size, int value) {
array = yon_remalloc(array, (*size+1)*sizeof(int));

14
source/philos_utils.h
Unescape View File

@ -20,12 +20,14 @@
#define file_source_login_min_max "/etc/login.defs"
static char** array_size_pow;
typedef struct {
char** disk;
char** disk_read;
char** disk_write;
int* i_o_limit_read;
int* i_o_limit_write;
int* i_o_limit_read_size;
int* i_o_limit_write_size;
int size;
int size_write;
int size_read;
} temp_config;
typedef struct {
@ -82,13 +84,13 @@ char** philos_str_split(char *parameters, int *size, char *divider);
void philos_array_str_copy(char*** source, char*** copy);
void philos_array_int_copy(int** source, int** copy);
char** philos_pars_terminal_systemd_cgls(char* CMD_GET_SLICE_SERVICE, char* str_find, int* size_array_data);
char* philos_pard_array_add_cmd(char* cmd, temp_config* _config, char* key, int* array_io, int* array_io_pow_size);
int philos_check_activ_disk(temp_set_window *widgets, temp_config* _config);
char* philos_pard_array_add_cmd(char* cmd, temp_config* _config, char* key, int* array_io, int* array_io_pow_size, char** disk, int size);
int philos_check_activ_disk(temp_set_window *widgets, temp_config* _config, int flag_check_array);
void philos_temp_generate_cmd(temp_set_window *widgets, temp_config* _config);
void philos_temp_del_disk(temp_set_window *widgets, temp_config* _config);
void philos_temp_del_disk(temp_set_window *widgets, temp_config* _config, int flag_check_array);
void philos_temp_config_init(temp_config* _config);
void philos_update_device_to_entry(temp_set_window *widgets, temp_config* _config, int flag_check_array);
void philos_temp_add_disk(temp_set_window *widgets, temp_config* _config);
void philos_temp_add_disk(temp_set_window *widgets, temp_config* _config, int flag_check_array);
int* philos_int_append(int* array, int* size, int value);
int* remove_element_int_array(int* array, int* size, int item_to_delete);
int** remove_element_int_array_n3(int** array, int* size, int item_to_delete);

78
source/ubl-settings-resourcequota.c
Unescape View File

@ -281,7 +281,8 @@ void clear_array() {
philos_free_int_array(&main_config.cpu_limit, main_config.size_tree_view);
philos_free_int_array_n2(&main_config.i_o_limit_read, main_config.size_tree_view);
philos_free_int_array_n2(&main_config.i_o_limit_write, main_config.size_tree_view);
philos_free_string_array_n3(&main_config.disk, main_config.size_tree_view);
philos_free_string_array_n3(&main_config.disk_read, main_config.size_tree_view);
philos_free_string_array_n3(&main_config.disk_write, main_config.size_tree_view);
philos_free_string_array(&main_config.array_del_line, main_config.size_array_del_line);
main_config.size_array_del_line = 0;
@ -299,7 +300,8 @@ void clear_array() {
main_config.i_o_limit_read_size = NULL;
main_config.i_o_limit_write = NULL;
main_config.i_o_limit_write_size = NULL;
main_config.disk = NULL;
main_config.disk_write = NULL;
main_config.disk_read = NULL;
main_config.size_tree_view = 0;
}
@ -364,18 +366,18 @@ void init_cfg_array(int index) {
index_n2 = 0;
main_config.i_o_limit_read = yon_remalloc(main_config.i_o_limit_read, (index + 1) * sizeof(int*));
main_config.i_o_limit_read_size = yon_remalloc(main_config.i_o_limit_read_size, (index + 1) * sizeof(int*));
main_config.disk = yon_remalloc(main_config.disk, (index + 1) * sizeof(char**));
main_config.disk_read = yon_remalloc(main_config.disk_read, (index + 1) * sizeof(char**));
main_config.i_o_limit_write = yon_remalloc(main_config.i_o_limit_write, (index + 1) * sizeof(int*));
main_config.i_o_limit_write_size = yon_remalloc(main_config.i_o_limit_write_size, (index + 1) * sizeof(int*));
main_config.disk = yon_remalloc(main_config.disk, (index + 1) * sizeof(char**));
main_config.disk_write = yon_remalloc(main_config.disk_write, (index + 1) * sizeof(char**));
philos_array_int_copy(&main_config.i_o_limit_read[index], &array_limit);
philos_array_int_copy(&main_config.i_o_limit_read_size[index], &array_limit);
yon_char_parsed_copy(&main_config.disk[index], &array_disk);
yon_char_parsed_copy(&main_config.disk_read[index], &array_disk);
philos_array_int_copy(&main_config.i_o_limit_write[main_config.size_tree_view], &array_limit);
philos_array_int_copy(&main_config.i_o_limit_write_size[main_config.size_tree_view], &array_limit);
yon_char_parsed_copy(&main_config.disk[main_config.size_tree_view], &array_disk);
philos_array_int_copy(&main_config.i_o_limit_write[index], &array_limit);
philos_array_int_copy(&main_config.i_o_limit_write_size[index], &array_limit);
yon_char_parsed_copy(&main_config.disk_write[index], &array_disk);
philos_free_int_array(&array_limit, 1);
philos_free_string_array(&array_disk, 1);
}
@ -474,12 +476,16 @@ void get_param_io_limit(char** arr_values, int index_start, int size, int index_
if (strstr(key_find, "IOReadBandwidthMax")!=NULL) {
array_limit = main_config.i_o_limit_read[index_n1];
array_limit_size = main_config.i_o_limit_read_size[index_n1];
array_disk = main_config.disk_read[index_n1];
}
else {
else if (strstr(key_find, "IOWriteBandwidthMax")!=NULL) {
array_limit = main_config.i_o_limit_write[index_n1];
array_limit_size = main_config.i_o_limit_write_size[index_n1];
array_disk = main_config.disk_write[index_n1];
}
else {
return;
}
array_disk = main_config.disk[index_n1];
int index_n2 = 0;
int flag_parsed = 0;
int flag_exit = 0;
@ -521,12 +527,12 @@ void get_param_io_limit(char** arr_values, int index_start, int size, int index_
if (strstr(key_find, "IOReadBandwidthMax")!=NULL) {
philos_array_int_copy(&main_config.i_o_limit_read[index_n1], &array_limit);
philos_array_int_copy(&main_config.i_o_limit_read_size[index_n1], &array_limit_size);
yon_char_parsed_copy(&main_config.disk[index_n1], &array_disk);
yon_char_parsed_copy(&main_config.disk_read[index_n1], &array_disk);
}
else {
else if (strstr(key_find, "IOWriteBandwidthMax")!=NULL) {
philos_array_int_copy(&main_config.i_o_limit_write[index_n1], &array_limit);
philos_array_int_copy(&main_config.i_o_limit_write_size[index_n1], &array_limit_size);
yon_char_parsed_copy(&main_config.disk[index_n1], &array_disk);
yon_char_parsed_copy(&main_config.disk_write[index_n1], &array_disk);
}
}
philos_free_int_array(&array_limit, index_n2);
@ -620,11 +626,13 @@ void tree_view_add(int index) {
main_config.i_o_limit_read = yon_remalloc(main_config.i_o_limit_read, (main_config.size_tree_view + 1) * sizeof(int*));
main_config.i_o_limit_read_size = yon_remalloc(main_config.i_o_limit_read_size, (main_config.size_tree_view + 1) * sizeof(int*));
main_config.disk = yon_remalloc(main_config.disk, (main_config.size_tree_view + 1) * sizeof(char**));
main_config.disk_read = yon_remalloc(main_config.disk_read, (main_config.size_tree_view + 1) * sizeof(char**));
yon_char_parsed_copy(&main_config.disk_read[main_config.size_tree_view], add_get_select_read_device());
philos_array_int_copy(&main_config.i_o_limit_read[main_config.size_tree_view], add_get_read_device());
philos_array_int_copy(&main_config.i_o_limit_read_size[main_config.size_tree_view], add_get_read_device_size_pow());
yon_char_parsed_copy(&main_config.disk[main_config.size_tree_view], add_get_select_device());
main_config.disk_write = yon_remalloc(main_config.disk_write, (main_config.size_tree_view + 1) * sizeof(char**));
yon_char_parsed_copy(&main_config.disk_write[main_config.size_tree_view], add_get_select_write_device());
main_config.i_o_limit_write = yon_remalloc(main_config.i_o_limit_write, (main_config.size_tree_view + 1) * sizeof(int*));
main_config.i_o_limit_write_size = yon_remalloc(main_config.i_o_limit_write_size, (main_config.size_tree_view + 1) * sizeof(int*));
philos_array_int_copy(&main_config.i_o_limit_write[main_config.size_tree_view], add_get_write_device());
@ -655,8 +663,8 @@ void fill_tree_view(int start, int size, int flag_gui_add) {
for (int index = start; index < size; index++) {
GtkTreeIter iter;
gtk_list_store_append(main_config.list,&iter);
char* str_io_read = format_io_limit_in_tree_view(main_config.disk, main_config.i_o_limit_read, main_config.i_o_limit_read_size, index);
char* str_io_write = format_io_limit_in_tree_view(main_config.disk, main_config.i_o_limit_write, main_config.i_o_limit_write_size, index);
char* str_io_read = format_io_limit_in_tree_view(main_config.disk_read, main_config.i_o_limit_read, main_config.i_o_limit_read_size, index);
char* str_io_write = format_io_limit_in_tree_view(main_config.disk_write, main_config.i_o_limit_write, main_config.i_o_limit_write_size, index);
gtk_list_store_set(main_config.list,&iter,
0,main_config.type_quota[index],
1,main_config.quota_volume[index],
@ -746,7 +754,8 @@ int tree_view_edit() {
philos_array_int_copy(&main_config.i_o_limit_read[index], edit_get_read_device());
philos_array_int_copy(&main_config.i_o_limit_read_size[index], edit_get_read_device_size_pow());
yon_char_parsed_copy(&main_config.disk[index], edit_get_select_device());
yon_char_parsed_copy(&main_config.disk_read[index], edit_get_select_read_device());
yon_char_parsed_copy(&main_config.disk_write[index], edit_get_select_write_device());
philos_array_int_copy(&main_config.i_o_limit_write[index], edit_get_write_device());
philos_array_int_copy(&main_config.i_o_limit_write_size[index], edit_get_write_device_size_pow());
@ -756,8 +765,8 @@ int tree_view_edit() {
main_config.swap_size[index] = edit_get_limit_swap_size();
main_config.cpu_limit_size[index] = edit_get_limit_cpu_size();
char* str_io_read = format_io_limit_in_tree_view(main_config.disk, main_config.i_o_limit_read, main_config.i_o_limit_read_size, index);
char* str_io_write = format_io_limit_in_tree_view(main_config.disk, main_config.i_o_limit_write, main_config.i_o_limit_write_size, index);
char* str_io_read = format_io_limit_in_tree_view(main_config.disk_read, main_config.i_o_limit_read, main_config.i_o_limit_read_size, index);
char* str_io_write = format_io_limit_in_tree_view(main_config.disk_write, main_config.i_o_limit_write, main_config.i_o_limit_write_size, index);
gtk_list_store_set(main_config.list,&iter,
0,main_config.type_quota[index],
1,main_config.quota_volume[index],
@ -864,14 +873,21 @@ void wrapper_edit_show() {
if(gtk_tree_selection_get_selected(selection, &model, &iter)) {
char* str_iter = gtk_tree_model_get_string_from_iter(model, &iter);
int index = atoi(str_iter);
size_t size_disk_array = 0;
if (main_config.disk) {
for (size_disk_array; main_config.disk[index][size_disk_array]; size_disk_array++) {
size_t size_disk_read_array = 0;
size_t size_disk_write_array = 0;
if (main_config.disk_read) {
for (size_disk_read_array=0; main_config.disk_read[index][size_disk_read_array]; size_disk_read_array++) {
}
}
if (main_config.disk_write) {
for (size_disk_write_array; main_config.disk_write[index][size_disk_write_array]; size_disk_write_array++) {
}
}
edit_show(NULL, glade_path);
edit_set_size_arrays(size_disk_array);
edit_set_select_device(&main_config.disk[index]);
edit_set_size_arrays_read(size_disk_read_array);
edit_set_size_arrays_write(size_disk_write_array);
edit_set_select_read_device(&main_config.disk_read[index]);
edit_set_select_write_device(&main_config.disk_write[index]);
edit_set_write_device(main_config.i_o_limit_write[index], main_config.i_o_limit_write_size[index]);
edit_set_read_device(main_config.i_o_limit_read[index], main_config.i_o_limit_read_size[index]);
edit_set_hard(main_config.hard_raw_limit[index], main_config.hard_raw_limit_size[index]);
@ -925,7 +941,9 @@ void tree_view_del_line() {
main_config.size_tree_view++;
main_config.i_o_limit_write = remove_element_int_array_n3(main_config.i_o_limit_write, &main_config.size_tree_view,index);
main_config.size_tree_view++;
main_config.disk = yon_char_parsed_shrink_n3(main_config.disk, &main_config.size_tree_view,index);
main_config.disk_read = yon_char_parsed_shrink_n3(main_config.disk_read, &main_config.size_tree_view,index);
main_config.size_tree_view++;
main_config.disk_write = yon_char_parsed_shrink_n3(main_config.disk_write, &main_config.size_tree_view,index);
main_config.size_tree_view++;
main_config.i_o_limit_read_size = remove_element_int_array_n3(main_config.i_o_limit_read_size, &main_config.size_tree_view,index);
@ -1038,8 +1056,8 @@ char* save_format_value(int index) {
split_simvol[1] = '\0';
}
char* value_read = add_io_str_format_ubconfig("IOReadBandwidthMax", main_config.i_o_limit_read, main_config.i_o_limit_read_size, main_config.disk, index);
char* value_write = add_io_str_format_ubconfig("IOWriteBandwidthMax", main_config.i_o_limit_write, main_config.i_o_limit_write_size, main_config.disk, index);
char* value_read = add_io_str_format_ubconfig("IOReadBandwidthMax", main_config.i_o_limit_read, main_config.i_o_limit_read_size, main_config.disk_read, index);
char* value_write = add_io_str_format_ubconfig("IOWriteBandwidthMax", main_config.i_o_limit_write, main_config.i_o_limit_write_size, main_config.disk_write, index);
if (strlen(value_read) > 5){
if (strlen(value) > 5) {
value = yon_char_unite(value, ",", value_read, NULL);
@ -1165,8 +1183,8 @@ void main_fill_tree_view_after_remove() {
for (int index= 0; index < main_config.size_tree_view; index++) {
GtkTreeIter iter;
gtk_list_store_append(main_config.list,&iter);
char* str_io_read = format_io_limit_in_tree_view(main_config.disk, main_config.i_o_limit_read, main_config.i_o_limit_read_size, index);
char* str_io_write = format_io_limit_in_tree_view(main_config.disk, main_config.i_o_limit_write, main_config.i_o_limit_write_size, index);
char* str_io_read = format_io_limit_in_tree_view(main_config.disk_read, main_config.i_o_limit_read, main_config.i_o_limit_read_size, index);
char* str_io_write = format_io_limit_in_tree_view(main_config.disk_write, main_config.i_o_limit_write, main_config.i_o_limit_write_size, index);
gtk_list_store_set(main_config.list,&iter,
0,main_config.type_quota[index],
1,main_config.quota_volume[index],

1
source/ubl-settings-resourcequota.h
Unescape View File

@ -81,7 +81,6 @@ typedef struct
int* cpu_limit;
int** i_o_limit_read;
int** i_o_limit_write;
config_str* disk;
config_str* disk_read;
config_str* disk_write;
config_str array_del_line;

51
source/view_add.c
Unescape View File

@ -72,8 +72,10 @@ void add_init_windows() {
void event_check_io_device() {
add_init_windows();
philos_temp_add_disk(add_widgets, &obj_add_config);
philos_temp_del_disk(add_widgets, &obj_add_config);
philos_temp_add_disk(add_widgets, &obj_add_config, 0);
philos_temp_add_disk(add_widgets, &obj_add_config, 1);
philos_temp_del_disk(add_widgets, &obj_add_config, 0);
philos_temp_del_disk(add_widgets, &obj_add_config, 1);
philos_temp_generate_cmd(add_widgets, &obj_add_config);
}
@ -177,39 +179,54 @@ char* add_get_select_device_to_level_2() {
}
int** add_get_read_device() {
obj_add_config.i_o_limit_read = philos_int_append(obj_add_config.i_o_limit_read,&obj_add_config.size, -2);
obj_add_config.size--;
obj_add_config.i_o_limit_read = philos_int_append(obj_add_config.i_o_limit_read,&obj_add_config.size_read, -2);
obj_add_config.size_read--;
return &obj_add_config.i_o_limit_read;
}
int** add_get_read_device_size_pow() {
obj_add_config.i_o_limit_read_size = philos_int_append(obj_add_config.i_o_limit_read_size,&obj_add_config.size, -2);
obj_add_config.size--;
obj_add_config.i_o_limit_read_size = philos_int_append(obj_add_config.i_o_limit_read_size,&obj_add_config.size_read, -2);
obj_add_config.size_read--;
return &obj_add_config.i_o_limit_read_size;
}
int** add_get_write_device() {
obj_add_config.i_o_limit_write = philos_int_append(obj_add_config.i_o_limit_write, &obj_add_config.size, -2);
obj_add_config.size--;
obj_add_config.i_o_limit_write = philos_int_append(obj_add_config.i_o_limit_write, &obj_add_config.size_write, -2);
obj_add_config.size_write--;
return &obj_add_config.i_o_limit_write;
}
int** add_get_write_device_size_pow() {
obj_add_config.i_o_limit_write_size = philos_int_append(obj_add_config.i_o_limit_write_size,&obj_add_config.size, -2);
obj_add_config.size--;
obj_add_config.i_o_limit_write_size = philos_int_append(obj_add_config.i_o_limit_write_size,&obj_add_config.size_write, -2);
obj_add_config.size_write--;
return &obj_add_config.i_o_limit_write_size;
}
char*** add_get_select_device() {
char*** add_get_select_read_device() {
int flag = 0;
if (obj_add_config.size == 0) {
obj_add_config.disk = yon_char_parsed_append(obj_add_config.disk,&obj_add_config.size, "-");
if (obj_add_config.size_read == 0) {
obj_add_config.disk_read = yon_char_parsed_append(obj_add_config.disk_read,&obj_add_config.size_read, "-");
flag = 1;
}
obj_add_config.disk = yon_char_parsed_append(obj_add_config.disk,&obj_add_config.size, NULL);
obj_add_config.disk_read = yon_char_parsed_append(obj_add_config.disk_read,&obj_add_config.size_read, NULL);
if (flag == 1) {
obj_add_config.size-=2;
obj_add_config.size_read-=2;
}
else {
obj_add_config.size-=1;
obj_add_config.size_read-=1;
}
return &obj_add_config.disk;
return &obj_add_config.disk_read;
}
char*** add_get_select_write_device() {
int flag = 0;
if (obj_add_config.size_read == 0) {
obj_add_config.disk_write = yon_char_parsed_append(obj_add_config.disk_write,&obj_add_config.size_write, "-");
flag = 1;
}
obj_add_config.disk_write = yon_char_parsed_append(obj_add_config.disk_write,&obj_add_config.size_write, NULL);
if (flag == 1) {
obj_add_config.size_write-=2;
}
else {
obj_add_config.size_write-=1;
}
return &obj_add_config.disk_write;
}
int add_get_soft_size() {

5
source/view_add.h
Unescape View File

@ -33,7 +33,7 @@ void add_destroy(GtkWidget *self);
void add_set_active_widgets(GtkWidget *check, GtkWidget *spin, GtkWidget *combo, int flag_cpu, char* cmd);
void add_init_windows();
void add_update_combo_box();
char*** add_get_select_device();
char*** add_get_select_read_device();
int** add_get_read_device();
int** add_get_write_device();
int add_get_soft();
@ -41,7 +41,8 @@ int add_get_hard();
int add_get_limit_cpu();
int add_get_limit_swap();
char* add_get_quota_object();
char*** add_get_select_write_device();
char*** add_get_select_read_device();
void combo_box_device();
int** add_get_write_device_size_pow();
int** add_get_read_device_size_pow();

85
source/view_edit.c
Unescape View File

@ -98,8 +98,10 @@ void edit_show(GtkWidget *self, char* glade_path) {
}
void wrapper_edit_init_windows_size_memory() {
philos_temp_add_disk(edit_widgets, &obj_edit_config);
philos_temp_del_disk(edit_widgets, &obj_edit_config);
philos_temp_add_disk(edit_widgets, &obj_edit_config, 0);
philos_temp_add_disk(edit_widgets, &obj_edit_config, 1);
philos_temp_del_disk(edit_widgets, &obj_edit_config, 0);
philos_temp_del_disk(edit_widgets, &obj_edit_config, 1);
edit_init_windows();
philos_temp_generate_cmd(edit_widgets, &obj_edit_config);
}
@ -171,36 +173,48 @@ int edit_get_quota_object_size() {
}
int** edit_get_read_device() {
obj_edit_config.i_o_limit_read = philos_int_append(obj_edit_config.i_o_limit_read,&obj_edit_config.size, -2);
obj_edit_config.size--;
obj_edit_config.i_o_limit_read = philos_int_append(obj_edit_config.i_o_limit_read,&obj_edit_config.size_read, -2);
obj_edit_config.size_read--;
return &obj_edit_config.i_o_limit_read;
}
int** edit_get_read_device_size_pow() {
obj_edit_config.i_o_limit_read_size = philos_int_append(obj_edit_config.i_o_limit_read_size,&obj_edit_config.size, -2);
obj_edit_config.size--;
obj_edit_config.i_o_limit_read_size = philos_int_append(obj_edit_config.i_o_limit_read_size,&obj_edit_config.size_read, -2);
obj_edit_config.size_read--;
return &obj_edit_config.i_o_limit_read_size;
}
int** edit_get_write_device() {
obj_edit_config.i_o_limit_write = philos_int_append(obj_edit_config.i_o_limit_write, &obj_edit_config.size, -2);
obj_edit_config.size--;
obj_edit_config.i_o_limit_write = philos_int_append(obj_edit_config.i_o_limit_write, &obj_edit_config.size_write, -2);
obj_edit_config.size_write--;
return &obj_edit_config.i_o_limit_write;
}
int** edit_get_write_device_size_pow() {
obj_edit_config.i_o_limit_write_size = philos_int_append(obj_edit_config.i_o_limit_write_size,&obj_edit_config.size, -2);
obj_edit_config.size--;
obj_edit_config.i_o_limit_write_size = philos_int_append(obj_edit_config.i_o_limit_write_size,&obj_edit_config.size_write, -2);
obj_edit_config.size_write--;
return &obj_edit_config.i_o_limit_write_size;
}
char*** edit_get_select_device() {
char*** edit_get_select_write_device() {
int index = 0;
if (!obj_edit_config.disk) {
obj_edit_config.disk = yon_char_parsed_append(obj_edit_config.disk,&index, "-");
obj_edit_config.disk = yon_char_parsed_append(obj_edit_config.disk,&index, NULL);
if (!obj_edit_config.disk_write) {
obj_edit_config.disk_write = yon_char_parsed_append(obj_edit_config.disk_write,&index, "-");
obj_edit_config.disk_write = yon_char_parsed_append(obj_edit_config.disk_write,&index, NULL);
}
if (index == 0) {
obj_edit_config.disk = yon_char_parsed_append(obj_edit_config.disk,&obj_edit_config.size, NULL);
obj_edit_config.size--;
obj_edit_config.disk_write = yon_char_parsed_append(obj_edit_config.disk_write,&obj_edit_config.size_write, NULL);
obj_edit_config.size_write--;
}
return &obj_edit_config.disk;
return &obj_edit_config.disk_write;
}
char*** edit_get_select_read_device() {
int index = 0;
if (!obj_edit_config.disk_read) {
obj_edit_config.disk_read = yon_char_parsed_append(obj_edit_config.disk_read,&index, "-");
obj_edit_config.disk_read = yon_char_parsed_append(obj_edit_config.disk_read,&index, NULL);
}
if (index == 0) {
obj_edit_config.disk_read = yon_char_parsed_append(obj_edit_config.disk_read,&obj_edit_config.size_read, NULL);
obj_edit_config.size_read--;
}
return &obj_edit_config.disk_read;
}
int edit_get_soft() {
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spiSevereRestrictionTemp));
@ -220,24 +234,44 @@ int edit_get_limit_swap() {
return gtk_spin_button_get_value_as_int(GTK_SPIN_BUTTON(edit_widgets->spinPaddingFLTemp));
}
void edit_set_select_device(char*** str_value) {
void edit_set_select_read_device(char*** str_value) {
if (str_value) {
if ((*str_value)) {
if ((*str_value)[0] != NULL && strstr((*str_value)[0], "-") == NULL) {
yon_char_parsed_copy(&obj_edit_config.disk, str_value);
yon_char_parsed_copy(&obj_edit_config.disk_read, str_value);
int index = yon_gtk_combo_box_text_find(edit_widgets->cbtTempDevice, (*str_value)[0]);
gtk_combo_box_set_active(GTK_COMBO_BOX(edit_widgets->cbtTempDevice), index);
}
else {
obj_edit_config.size = 0;
obj_edit_config.size_read = 0;
}
}
else {
obj_edit_config.size = 0;
obj_edit_config.size_read = 0;
}
}
else {
obj_edit_config.size = 0;
obj_edit_config.size_read = 0;
}
}
void edit_set_select_write_device(char*** str_value) {
if (str_value) {
if ((*str_value)) {
if ((*str_value)[0] != NULL && strstr((*str_value)[0], "-") == NULL) {
yon_char_parsed_copy(&obj_edit_config.disk_write, str_value);
int index = yon_gtk_combo_box_text_find(edit_widgets->cbtTempDevice, (*str_value)[0]);
gtk_combo_box_set_active(GTK_COMBO_BOX(edit_widgets->cbtTempDevice), index);
}
else {
obj_edit_config.size_write = 0;
}
}
else {
obj_edit_config.size_write = 0;
}
}
else {
obj_edit_config.size_write = 0;
}
}
void edit_set_read_device(int* str_value, int* pow_mem) {
@ -266,8 +300,11 @@ void edit_set_write_device(int* str_value, int* pow_mem) {
}
}
void edit_set_size_arrays(size_t size_array) {
obj_edit_config.size = size_array;
void edit_set_size_arrays_write(size_t size_array) {
obj_edit_config.size_write = size_array;
}
void edit_set_size_arrays_read(size_t size_array) {
obj_edit_config.size_read = size_array;
}
void edit_set_soft(int value, int pow_mem) {
edit_temp_set(value,pow_mem, edit_widgets->chkSoftRestrictionTemp,

9
source/view_edit.h
Unescape View File

@ -30,7 +30,8 @@ void edit_destroy(GtkWidget *self);
void edit_init_windows();
void wrapper_edit_init_windows_size_memory();
void edit_set_active_widgets(GtkWidget *check, GtkWidget *spin, GtkWidget *combo, int flag_cpu, char* cmd);
char*** edit_get_select_device();
char*** edit_get_select_read_device();
char*** edit_get_select_write_device();
int** edit_get_read_device();
int** edit_get_write_device();
int edit_get_soft();
@ -38,7 +39,8 @@ int edit_get_hard();
int edit_get_limit_cpu();
int edit_get_limit_swap();
void wrapper_edit_show();
void edit_set_select_device(char*** str_value);
void edit_set_select_write_device(char*** str_value);
void edit_set_select_read_device(char*** str_value);
void edit_set_read_device(int* str_value, int* pow_mem);
void edit_set_write_device(int* str_value, int* pow_mem);
void edit_set_soft(int value, int pow_mem);
@ -49,7 +51,8 @@ void edit_temp_set(int value, int pow_mem, GtkWidget* cheek, GtkWidget* spin, Gt
int** edit_get_read_device_size_pow();
int** edit_get_write_device_size_pow();
void edit_set_size_arrays(size_t size_array);
void edit_set_size_arrays_read(size_t size_array);
void edit_set_size_arrays_write(size_t size_array);
int edit_get_soft_size();
int edit_get_hard_size();
int edit_get_limit_cpu_size();

Write Preview
Loading…
Cancel
Save