[pve-network.git] / PVE / API2 / Network / SDN / Controllers.pm

package PVE::API2::Network::SDN::Controllers;

use strict;
use warnings;

use PVE::SafeSyslog;
use PVE::Tools qw(extract_param);
use PVE::Cluster qw(cfs_read_file cfs_write_file);
use PVE::Network::SDN;
use PVE::Network::SDN::Zones;
use PVE::Network::SDN::Controllers;
use PVE::Network::SDN::Controllers::Plugin;
use PVE::Network::SDN::Controllers::EvpnPlugin;
use PVE::Network::SDN::Controllers::FaucetPlugin;

use Storable qw(dclone);
use PVE::JSONSchema qw(get_standard_option);
use PVE::RPCEnvironment;

use PVE::RESTHandler;

use base qw(PVE::RESTHandler);

my $sdn_controllers_type_enum = PVE::Network::SDN::Controllers::Plugin->lookup_types();

my $api_sdn_controllers_config = sub {
    my ($cfg, $id) = @_;

    my $scfg = dclone(PVE::Network::SDN::Controllers::sdn_controllers_config($cfg, $id));
    $scfg->{controller} = $id;
    $scfg->{digest} = $cfg->{digest};

    return $scfg;
};

__PACKAGE__->register_method ({
    name => 'index',
    path => '',
    method => 'GET',
    description => "SDN controllers index.",
    permissions => {
	description => "Only list entries where you have 'SDN.Audit' or 'SDN.Allocate' permissions on '/sdn/controllers/<controller>'",
	user => 'all',
    },
    parameters => {
    	additionalProperties => 0,
	properties => {
	    type => {
		description => "Only list sdn controllers of specific type",
		type => 'string',
		enum => $sdn_controllers_type_enum,
		optional => 1,
	    },
	    running => {
		type => 'boolean',
		optional => 1,
		description => "Display running config.",
	    },
	    pending => {
		type => 'boolean',
		optional => 1,
		description => "Display pending config.",
	    },
	},
    },
    returns => {
	type => 'array',
	items => {
	    type => "object",
	    properties => { controller => { type => 'string' },
			    type => { type => 'string' },
			    state => { type => 'string', optional => 1 },
                            pending => { optional => 1},
	    },
	},
	links => [ { rel => 'child', href => "{controller}" } ],
    },
    code => sub {
	my ($param) = @_;

	my $rpcenv = PVE::RPCEnvironment::get();
	my $authuser = $rpcenv->get_user();

        my $cfg = {};
        if($param->{pending}) {
            my $running_cfg = PVE::Network::SDN::config();
            my $config = PVE::Network::SDN::Controllers::config();
            $cfg = PVE::Network::SDN::pending_config($running_cfg, $config, 'controllers');
        } elsif ($param->{running}) {
            my $running_cfg = PVE::Network::SDN::config();
            $cfg = $running_cfg->{controllers};
        } else {
            $cfg = PVE::Network::SDN::Controllers::config();
        }

	my @sids = PVE::Network::SDN::Controllers::sdn_controllers_ids($cfg);
	my $res = [];
	foreach my $id (@sids) {
	    my $privs = [ 'SDN.Audit', 'SDN.Allocate' ];
	    next if !$rpcenv->check_any($authuser, "/sdn/controllers/$id", $privs, 1);

	    my $scfg = &$api_sdn_controllers_config($cfg, $id);
	    next if $param->{type} && $param->{type} ne $scfg->{type};

	    my $plugin_config = $cfg->{ids}->{$id};
	    my $plugin = PVE::Network::SDN::Controllers::Plugin->lookup($plugin_config->{type});
	    push @$res, $scfg;
	}

	return $res;
    }});

__PACKAGE__->register_method ({
    name => 'read',
    path => '{controller}',
    method => 'GET',
    description => "Read sdn controller configuration.",
    permissions => {
	check => ['perm', '/sdn/controllers/{controller}', ['SDN.Allocate']],
   },

    parameters => {
    	additionalProperties => 0,
	properties => {
	    controller => get_standard_option('pve-sdn-controller-id'),
	    running => {
		type => 'boolean',
		optional => 1,
		description => "Display running config.",
	    },
	    pending => {
		type => 'boolean',
		optional => 1,
		description => "Display pending config.",
	    },
	},
    },
    returns => { type => 'object' },
    code => sub {
	my ($param) = @_;

        my $cfg = {};
        if($param->{pending}) {
            my $running_cfg = PVE::Network::SDN::config();
            my $config = PVE::Network::SDN::Controllers::config();
            $cfg = PVE::Network::SDN::pending_config($running_cfg, $config, 'controllers');
        } elsif ($param->{running}) {
            my $running_cfg = PVE::Network::SDN::config();
            $cfg = $running_cfg->{controllers};
        } else {
            $cfg = PVE::Network::SDN::Controllers::config();
        }

	return &$api_sdn_controllers_config($cfg, $param->{controller});
    }});

__PACKAGE__->register_method ({
    name => 'create',
    protected => 1,
    path => '',
    method => 'POST',
    description => "Create a new sdn controller object.",
    permissions => {
	check => ['perm', '/sdn/controllers', ['SDN.Allocate']],
    },
    parameters => PVE::Network::SDN::Controllers::Plugin->createSchema(),
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $type = extract_param($param, 'type');
	my $id = extract_param($param, 'controller');

	my $plugin = PVE::Network::SDN::Controllers::Plugin->lookup($type);
	my $opts = $plugin->check_config($id, $param, 1, 1);

        # create /etc/pve/sdn directory
        PVE::Cluster::check_cfs_quorum();
        mkdir("/etc/pve/sdn");

        PVE::Network::SDN::lock_sdn_config(
	    sub {

		my $controller_cfg = PVE::Network::SDN::Controllers::config();

		my $scfg = undef;
		if ($scfg = PVE::Network::SDN::Controllers::sdn_controllers_config($controller_cfg, $id, 1)) {
		    die "sdn controller object ID '$id' already defined\n";
		}

		$controller_cfg->{ids}->{$id} = $opts;
		$plugin->on_update_hook($id, $controller_cfg);

		PVE::Network::SDN::Controllers::write_config($controller_cfg);

	    }, "create sdn controller object failed");

	return undef;
    }});

__PACKAGE__->register_method ({
    name => 'update',
    protected => 1,
    path => '{controller}',
    method => 'PUT',
    description => "Update sdn controller object configuration.",
    permissions => {
	check => ['perm', '/sdn/controllers', ['SDN.Allocate']],
    },
    parameters => PVE::Network::SDN::Controllers::Plugin->updateSchema(),
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $id = extract_param($param, 'controller');
	my $digest = extract_param($param, 'digest');

        PVE::Network::SDN::lock_sdn_config(
	 sub {

	    my $controller_cfg = PVE::Network::SDN::Controllers::config();

	    PVE::SectionConfig::assert_if_modified($controller_cfg, $digest);

	    my $scfg = PVE::Network::SDN::Controllers::sdn_controllers_config($controller_cfg, $id);

	    my $plugin = PVE::Network::SDN::Controllers::Plugin->lookup($scfg->{type});
	    my $opts = $plugin->check_config($id, $param, 0, 1);

	    foreach my $k (%$opts) {
		$scfg->{$k} = $opts->{$k};
	    }

	    $plugin->on_update_hook($id, $controller_cfg);

	    PVE::Network::SDN::Controllers::write_config($controller_cfg);


	    }, "update sdn controller object failed");

	return undef;
    }});

__PACKAGE__->register_method ({
    name => 'delete',
    protected => 1,
    path => '{controller}',
    method => 'DELETE',
    description => "Delete sdn controller object configuration.",
    permissions => {
	check => ['perm', '/sdn/controllers', ['SDN.Allocate']],
    },
    parameters => {
    	additionalProperties => 0,
	properties => {
	    controller => get_standard_option('pve-sdn-controller-id', {
                completion => \&PVE::Network::SDN::Controllers::complete_sdn_controllers,
            }),
	},
    },
    returns => { type => 'null' },
    code => sub {
	my ($param) = @_;

	my $id = extract_param($param, 'controller');

        PVE::Network::SDN::lock_sdn_config(
	    sub {

		my $cfg = PVE::Network::SDN::Controllers::config();

		my $scfg = PVE::Network::SDN::Controllers::sdn_controllers_config($cfg, $id);

		my $plugin = PVE::Network::SDN::Controllers::Plugin->lookup($scfg->{type});

		my $zone_cfg = PVE::Network::SDN::Zones::config();

		$plugin->on_delete_hook($id, $zone_cfg);

		delete $cfg->{ids}->{$id};
		PVE::Network::SDN::Controllers::write_config($cfg);

	    }, "delete sdn controller object failed");


	return undef;
    }});

1;
Commit	Line	Data
4140be9e AD	1	package PVE::API2::Network::SDN::Controllers;
	2
	3	use strict;
	4	use warnings;
	5
	6	use PVE::SafeSyslog;
	7	use PVE::Tools qw(extract_param);
	8	use PVE::Cluster qw(cfs_read_file cfs_write_file);
f9bc9640	9	use PVE::Network::SDN;
4140be9e AD	10	use PVE::Network::SDN::Zones;
	11	use PVE::Network::SDN::Controllers;
	12	use PVE::Network::SDN::Controllers::Plugin;
fa253735	13	use PVE::Network::SDN::Controllers::EvpnPlugin;
4140be9e AD	14	use PVE::Network::SDN::Controllers::FaucetPlugin;
	15
	16	use Storable qw(dclone);
	17	use PVE::JSONSchema qw(get_standard_option);
	18	use PVE::RPCEnvironment;
	19
	20	use PVE::RESTHandler;
	21
	22	use base qw(PVE::RESTHandler);
	23
	24	my $sdn_controllers_type_enum = PVE::Network::SDN::Controllers::Plugin->lookup_types();
	25
	26	my $api_sdn_controllers_config = sub {
	27	my ($cfg, $id) = @_;
	28
	29	my $scfg = dclone(PVE::Network::SDN::Controllers::sdn_controllers_config($cfg, $id));
	30	$scfg->{controller} = $id;
	31	$scfg->{digest} = $cfg->{digest};
	32
	33	return $scfg;
	34	};
	35
	36	__PACKAGE__->register_method ({
	37	name => 'index',
	38	path => '',
	39	method => 'GET',
	40	description => "SDN controllers index.",
	41	permissions => {
3551b612	42	description => "Only list entries where you have 'SDN.Audit' or 'SDN.Allocate' permissions on '/sdn/controllers/<controller>'",
4140be9e AD	43	user => 'all',
	44	},
	45	parameters => {
	46	additionalProperties => 0,
	47	properties => {
	48	type => {
	49	description => "Only list sdn controllers of specific type",
	50	type => 'string',
	51	enum => $sdn_controllers_type_enum,
	52	optional => 1,
	53	},
6f5f42e4 AD	54	running => {
	55	type => 'boolean',
	56	optional => 1,
	57	description => "Display running config.",
	58	},
	59	pending => {
	60	type => 'boolean',
	61	optional => 1,
	62	description => "Display pending config.",
	63	},
4140be9e AD	64	},
	65	},
	66	returns => {
	67	type => 'array',
	68	items => {
	69	type => "object",
6f5f42e4 AD	70	properties => { controller => { type => 'string' },
	71	type => { type => 'string' },
	72	state => { type => 'string', optional => 1 },
	73	pending => { optional => 1},
	74	},
4140be9e AD	75	},
	76	links => [ { rel => 'child', href => "{controller}" } ],
	77	},
	78	code => sub {
	79	my ($param) = @_;
	80
	81	my $rpcenv = PVE::RPCEnvironment::get();
	82	my $authuser = $rpcenv->get_user();
	83
6f5f42e4 AD	84	my $cfg = {};
	85	if($param->{pending}) {
	86	my $running_cfg = PVE::Network::SDN::config();
	87	my $config = PVE::Network::SDN::Controllers::config();
	88	$cfg = PVE::Network::SDN::pending_config($running_cfg, $config, 'controllers');
	89	} elsif ($param->{running}) {
	90	my $running_cfg = PVE::Network::SDN::config();
	91	$cfg = $running_cfg->{controllers};
	92	} else {
	93	$cfg = PVE::Network::SDN::Controllers::config();
	94	}
4140be9e AD	95
	96	my @sids = PVE::Network::SDN::Controllers::sdn_controllers_ids($cfg);
	97	my $res = [];
	98	foreach my $id (@sids) {
3551b612 AD	99	my $privs = [ 'SDN.Audit', 'SDN.Allocate' ];
3551b612 AD	100	next if !$rpcenv->check_any($authuser, "/sdn/controllers/$id", $privs, 1);
4140be9e AD	101
	102	my $scfg = &$api_sdn_controllers_config($cfg, $id);
	103	next if $param->{type} && $param->{type} ne $scfg->{type};
	104
	105	my $plugin_config = $cfg->{ids}->{$id};
	106	my $plugin = PVE::Network::SDN::Controllers::Plugin->lookup($plugin_config->{type});
	107	push @$res, $scfg;
	108	}
	109
	110	return $res;
	111	}});
	112
	113	__PACKAGE__->register_method ({
	114	name => 'read',
	115	path => '{controller}',
	116	method => 'GET',
	117	description => "Read sdn controller configuration.",
3551b612 AD	118	permissions => {
	119	check => ['perm', '/sdn/controllers/{controller}', ['SDN.Allocate']],
	120	},
4140be9e AD	121
	122	parameters => {
	123	additionalProperties => 0,
	124	properties => {
	125	controller => get_standard_option('pve-sdn-controller-id'),
6f5f42e4 AD	126	running => {
	127	type => 'boolean',
	128	optional => 1,
	129	description => "Display running config.",
	130	},
	131	pending => {
	132	type => 'boolean',
	133	optional => 1,
	134	description => "Display pending config.",
	135	},
4140be9e AD	136	},
	137	},
	138	returns => { type => 'object' },
	139	code => sub {
	140	my ($param) = @_;
	141
6f5f42e4 AD	142	my $cfg = {};
	143	if($param->{pending}) {
	144	my $running_cfg = PVE::Network::SDN::config();
	145	my $config = PVE::Network::SDN::Controllers::config();
	146	$cfg = PVE::Network::SDN::pending_config($running_cfg, $config, 'controllers');
	147	} elsif ($param->{running}) {
	148	my $running_cfg = PVE::Network::SDN::config();
	149	$cfg = $running_cfg->{controllers};
	150	} else {
	151	$cfg = PVE::Network::SDN::Controllers::config();
	152	}
4140be9e AD	153
	154	return &$api_sdn_controllers_config($cfg, $param->{controller});
	155	}});
	156
	157	__PACKAGE__->register_method ({
	158	name => 'create',
	159	protected => 1,
	160	path => '',
	161	method => 'POST',
	162	description => "Create a new sdn controller object.",
3551b612 AD	163	permissions => {
	164	check => ['perm', '/sdn/controllers', ['SDN.Allocate']],
	165	},
4140be9e AD	166	parameters => PVE::Network::SDN::Controllers::Plugin->createSchema(),
	167	returns => { type => 'null' },
	168	code => sub {
	169	my ($param) = @_;
	170
	171	my $type = extract_param($param, 'type');
	172	my $id = extract_param($param, 'controller');
	173
	174	my $plugin = PVE::Network::SDN::Controllers::Plugin->lookup($type);
	175	my $opts = $plugin->check_config($id, $param, 1, 1);
	176
45c3f15c AD	177	# create /etc/pve/sdn directory
	178	PVE::Cluster::check_cfs_quorum();
	179	mkdir("/etc/pve/sdn");
	180
f9bc9640	181	PVE::Network::SDN::lock_sdn_config(
4140be9e AD	182	sub {
4140be9e AD	183
56cdcac9	184	my $controller_cfg = PVE::Network::SDN::Controllers::config();
4140be9e AD	185
4140be9e AD	186	my $scfg = undef;
56cdcac9	187	if ($scfg = PVE::Network::SDN::Controllers::sdn_controllers_config($controller_cfg, $id, 1)) {
4140be9e AD	188	die "sdn controller object ID '$id' already defined\n";
	189	}
	190
56cdcac9 AD	191	$controller_cfg->{ids}->{$id} = $opts;
56cdcac9 AD	192	$plugin->on_update_hook($id, $controller_cfg);
4140be9e	193
56cdcac9	194	PVE::Network::SDN::Controllers::write_config($controller_cfg);
4140be9e AD	195
	196	}, "create sdn controller object failed");
	197
	198	return undef;
	199	}});
	200
4140be9e AD	201	__PACKAGE__->register_method ({
	202	name => 'update',
	203	protected => 1,
	204	path => '{controller}',
	205	method => 'PUT',
	206	description => "Update sdn controller object configuration.",
3551b612 AD	207	permissions => {
	208	check => ['perm', '/sdn/controllers', ['SDN.Allocate']],
	209	},
4140be9e AD	210	parameters => PVE::Network::SDN::Controllers::Plugin->updateSchema(),
	211	returns => { type => 'null' },
	212	code => sub {
	213	my ($param) = @_;
	214
	215	my $id = extract_param($param, 'controller');
	216	my $digest = extract_param($param, 'digest');
	217
f9bc9640	218	PVE::Network::SDN::lock_sdn_config(
4140be9e AD	219	sub {
4140be9e AD	220
56cdcac9	221	my $controller_cfg = PVE::Network::SDN::Controllers::config();
4140be9e	222
56cdcac9	223	PVE::SectionConfig::assert_if_modified($controller_cfg, $digest);
4140be9e	224
56cdcac9	225	my $scfg = PVE::Network::SDN::Controllers::sdn_controllers_config($controller_cfg, $id);
4140be9e AD	226
	227	my $plugin = PVE::Network::SDN::Controllers::Plugin->lookup($scfg->{type});
	228	my $opts = $plugin->check_config($id, $param, 0, 1);
	229
	230	foreach my $k (%$opts) {
	231	$scfg->{$k} = $opts->{$k};
	232	}
	233
56cdcac9	234	$plugin->on_update_hook($id, $controller_cfg);
4140be9e	235
56cdcac9	236	PVE::Network::SDN::Controllers::write_config($controller_cfg);
4140be9e	237
f9bc9640	238
4140be9e AD	239	}, "update sdn controller object failed");
	240
	241	return undef;
	242	}});
	243
	244	__PACKAGE__->register_method ({
	245	name => 'delete',
	246	protected => 1,
	247	path => '{controller}',
	248	method => 'DELETE',
	249	description => "Delete sdn controller object configuration.",
3551b612 AD	250	permissions => {
	251	check => ['perm', '/sdn/controllers', ['SDN.Allocate']],
	252	},
4140be9e AD	253	parameters => {
	254	additionalProperties => 0,
	255	properties => {
	256	controller => get_standard_option('pve-sdn-controller-id', {
	257	completion => \&PVE::Network::SDN::Controllers::complete_sdn_controllers,
	258	}),
	259	},
	260	},
	261	returns => { type => 'null' },
	262	code => sub {
	263	my ($param) = @_;
	264
	265	my $id = extract_param($param, 'controller');
	266
f9bc9640	267	PVE::Network::SDN::lock_sdn_config(
4140be9e AD	268	sub {
	269
	270	my $cfg = PVE::Network::SDN::Controllers::config();
	271
	272	my $scfg = PVE::Network::SDN::Controllers::sdn_controllers_config($cfg, $id);
	273
	274	my $plugin = PVE::Network::SDN::Controllers::Plugin->lookup($scfg->{type});
	275
56cdcac9	276	my $zone_cfg = PVE::Network::SDN::Zones::config();
4140be9e	277
56cdcac9	278	$plugin->on_delete_hook($id, $zone_cfg);
4140be9e AD	279
	280	delete $cfg->{ids}->{$id};
	281	PVE::Network::SDN::Controllers::write_config($cfg);
	282
	283	}, "delete sdn controller object failed");
	284
	285
	286	return undef;
	287	}});
	288
	289	1;