Controllers management

src/xdpd/management/plugins/config/openflow/lsi_scope.cc

@@ -294,7 +294,7 @@ void lsi_scope::post_validate(libconfig::Setting& setting, bool dry_run){
 
 		//Connect(1..N-1)
 		for(std::vector<lsi_connection>::iterator it = (conns.begin()+1); it != conns.end(); ++it) {
-			switch_manager::rpc_connect_to_ctl(dpid, it->type, it->params); 
+			switch_manager::connect_to_ctl(dpid, it->type, it->params);
 		}	
 	}
 }

src/xdpd/management/plugins/rest/delete-controllers.h

@@ -12,6 +12,7 @@ namespace delete_{
 	* Destroy an LSI
 	*/
 	void destroy_switch(const http::server::request &, http::server::reply &, boost::cmatch&);
+	void rem_ctl(const http::server::request &, http::server::reply &, boost::cmatch&);
 
 } //namespace delete_
 } //namespace controllers

src/xdpd/management/plugins/rest/get-controllers.h

@@ -35,6 +35,12 @@ namespace get{
 	void list_ports(const http::server::request &, http::server::reply &, boost::cmatch&);
 	void port_detail(const http::server::request &, http::server::reply &, boost::cmatch&);
 
+	/**
+	 * Controllers
+	 */
+	void list_ctls(const http::server::request &, http::server::reply &, boost::cmatch&);
+	void show_ctl(const http::server::request &, http::server::reply &, boost::cmatch&);
+
 } //namespace get
 } //namespace controllers
 } //namespace xdpd

src/xdpd/management/plugins/rest/put-controllers.h

@@ -18,6 +18,11 @@ namespace put{
 	*/
 	void create_vlink(const http::server::request &, http::server::reply &, boost::cmatch&);
 
+	/*
+	* Add a new controller to the LSI
+	*/
+	void add_ctl(const http::server::request &, http::server::reply &, boost::cmatch&);
+
 } //namespace put
 } //namespace controllers
 } //namespace xdpd

src/xdpd/management/plugins/rest/rest.cc

@@ -82,6 +82,10 @@ static void srvthread (){
 		handler.register_get_path("/info/lsi/(\\w+)/table/([0-9]+)/flows", boost::bind(controllers::get::lsi_table_flows, _1, _2, _3));
 		handler.register_get_path("/info/lsi/(\\w+)/group-table", boost::bind(controllers::get::lsi_groups, _1, _2, _3));
 
+		//Controllers
+		handler.register_get_path("/info/lsi/(\\w+)/controllers", boost::bind(controllers::get::list_ctls, _1, _2, _3));
+		handler.register_get_path("/info/lsi/(\\w+)/controller/(\\w+)", boost::bind(controllers::get::show_ctl, _1, _2, _3));
+
 		//
 		// POST
 		//
@@ -99,11 +103,17 @@ static void srvthread (){
 		handler.register_post_path("/mgmt/create/lsi", boost::bind(controllers::put::create_lsi, _1, _2, _3));
 		handler.register_put_path("/mgmt/create/vlink/(\\w+)/(\\w+)", boost::bind(controllers::put::create_vlink, _1, _2, _3));
 
+		// Controllers
+		handler.register_put_path("/mgmt/add/controller/(\\w+)", boost::bind(controllers::put::add_ctl, _1, _2, _3));
+
 		//
 		//DELETE
 		//
 		handler.register_delete_path("/mgmt/destroy/lsi/(\\w+)", boost::bind(controllers::delete_::destroy_switch, _1, _2, _3));
 
+		// Controllers
+		handler.register_delete_path("/mgmt/remove/controller/(\\w+)/(\\w+)", boost::bind(controllers::delete_::rem_ctl, _1, _2, _3));
+
 		//Recover host and port
 		parse_bind_addr(host, port);
 

src/xdpd/management/plugins/rest/sw-controllers.cc

@@ -236,6 +236,102 @@ void lsi_groups(const http::server::request &req,
 	rep.content = json_spirit::write(wrap, true);
 }
 
+void list_ctls(const http::server::request &req, http::server::reply &rep, boost::cmatch& grps){
+	std::string lsi_name;
+	uint64_t dpid;
+	std::list<rofl::cctlid> list;
+	json_spirit::Object table;
+
+	//Perform security checks
+        if(!authorised(req,rep)) return;
+
+	lsi_name = std::string(grps[1]);
+
+	// Get dpid
+	if(!switch_manager::exists_by_name(lsi_name)){
+		//Throw 404
+		std::stringstream ss;
+		ss<<"Invalid lsi '"<<lsi_name<<"'";
+		rep.content = ss.str();
+		rep.status = http::server::reply::not_found;
+		return;
+	}
+	dpid = switch_manager::get_switch_dpid(lsi_name);
+
+	try{
+		switch_manager::list_ctls(dpid, &list);
+	}catch(...){
+		throw "Unable to get list of ctls from lsi";
+	}
+
+	//Return data
+	std::list<std::string> list_str;
+	for(std::list<rofl::cctlid>::iterator it = list.begin(); it != list.end(); it++){
+		std::stringstream ss_tmp;
+		ss_tmp << it->get_ctlid();
+		list_str.push_back(ss_tmp.str());
+	}
+
+	json_spirit::Value ids_(list_str.begin(), list_str.end());
+	table.push_back(json_spirit::Pair("controller-ids", ids_));
+	rep.content = json_spirit::write(table, true);
+}
+
+void show_ctl(const http::server::request &req, http::server::reply &rep, boost::cmatch& grps){
+	std::string lsi_name; //, ctl_id;
+	uint64_t dpid, ctl_id;
+	controller_snapshot ctl_info;
+	json_spirit::Object j_wrap, j_ctl, j_list;
+
+	//Perform security checks
+        if(!authorised(req,rep)) return;
+
+	lsi_name = std::string(grps[1]);
+	ctl_id = atoi(std::string(grps[2]).c_str());
+
+
+	// Get dpid
+	if(!switch_manager::exists_by_name(lsi_name)){
+		//Throw 404
+		std::stringstream ss;
+		ss<<"Invalid lsi '"<<lsi_name<<"'";
+		rep.content = ss.str();
+		rep.status = http::server::reply::not_found;
+		return;
+	}
+
+	dpid = switch_manager::get_switch_dpid(lsi_name);
+
+	try{
+		switch_manager::get_controller_info(dpid, ctl_id, ctl_info);
+	}catch(...){
+		throw "Unable to get Controller info for lsi";
+	}
+
+	j_ctl.push_back(json_spirit::Pair("id", ctl_info.id));
+	j_ctl.push_back(json_spirit::Pair("channel-status", ctl_info.get_status_str()));
+	j_ctl.push_back(json_spirit::Pair("mode", ctl_info.get_role_str()));
+
+	std::list<controller_conn_snapshot>::const_iterator it;
+	for(it=ctl_info.conn_list.begin(); it != ctl_info.conn_list.end(); ++it){
+		json_spirit::Object j_conn;
+		j_conn.push_back(json_spirit::Pair("protocol-type", it->get_proto_type_str()));
+		j_conn.push_back(json_spirit::Pair("ip", it->ip));
+		j_conn.push_back(json_spirit::Pair("port", it->port));
+
+		std::stringstream ss;
+		ss << it->id;
+		j_list.push_back(json_spirit::Pair(ss.str(), j_conn));
+
+	}
+
+	j_ctl.push_back(json_spirit::Pair("connections", j_list));
+
+	//Return data
+	j_wrap.push_back(json_spirit::Pair("Controller", j_ctl));
+	rep.content = json_spirit::write(j_wrap, true);
+}
+
 } //namespace get
 
 
@@ -358,6 +454,87 @@ void create_lsi(const http::server::request &req, http::server::reply &rep, boos
 	//There is no need to return anything
 }
 
+
+void add_ctl(const http::server::request &req, http::server::reply &rep, boost::cmatch& grps){
+
+	//call switch_manager to add a new controller to the LSI
+	// get IP & port from the req parameter (json?)
+	// check IP & port (if there is already a controller there, send error message)
+	std::string proto, ip, port;
+	enum rofl::csocket::socket_type_t socket_type;
+	rofl::cparams socket_params;
+	json_spirit::Object table;
+	uint64_t assigned_id;
+
+	//Perform security checks
+        if(!authorised(req,rep)) return;
+
+	std::string lsi_name = std::string(grps[1]);
+
+	//Check if LSI exists;
+        if(!switch_manager::exists_by_name(lsi_name)){
+                //Throw 404
+                std::stringstream ss;
+                ss<<"Invalid lsi '"<<lsi_name<<"'";
+                rep.content = ss.str();
+                rep.status = http::server::reply::not_found;
+                return;
+        }
+
+	// Get dpid check for failure
+	uint64_t dpid = switch_manager::get_switch_dpid(lsi_name);
+
+	// Parse data (protocol, IP & port)
+	try{
+		//Parse the input
+		json_spirit::Value val;
+
+		//First object must be "lsi"
+		json_spirit::read(req.content, val);
+
+		json_spirit::Object obj = val.get_obj();
+		obj = json_spirit::find_value(obj, "ctl").get_obj();
+
+		//Fill in parameters
+		proto = json_spirit::find_value(obj, "proto").get_str();
+		ip = json_spirit::find_value(obj, "ip").get_str();
+		port = json_spirit::find_value(obj, "port").get_str();
+
+	}catch(...){
+		std::stringstream ss;
+		ss<<"Unable to parse arguments for add controller";
+		rep.content = ss.str();
+		rep.status = http::server::reply::bad_request;
+		return;
+	}
+
+
+	//TODO Check parameters received (proto, ip & port)
+	if ( proto == "tcp" ){
+		socket_type = rofl::csocket::SOCKET_TYPE_PLAIN;
+	} else {
+		// TODO Other types not yet  supported (SOCKET_TYPE_OPENSSL)
+		std::stringstream ss;
+		ss<<"Invalid protocol '"<<lsi_name<<"'";
+		rep.content = ss.str();
+		rep.status = http::server::reply::bad_request;
+		return;
+	}
+	socket_params = rofl::csocket::get_default_params(socket_type);
+	socket_params.set_param(rofl::csocket::PARAM_KEY_REMOTE_HOSTNAME) = ip;
+	socket_params.set_param(rofl::csocket::PARAM_KEY_REMOTE_PORT) = port;
+
+	try{
+		assigned_id = switch_manager::connect_to_ctl(dpid, socket_type, socket_params);
+	}catch(...){
+                throw "Unable to add controller to lsi";
+	}
+
+	//Return assigned ID
+	table.push_back(json_spirit::Pair("assigned id", assigned_id));
+	rep.content = json_spirit::write(table, true);
+}
+
 } //namespace put
 
 namespace delete_{
@@ -395,6 +572,42 @@ void destroy_switch(const http::server::request &req, http::server::reply &rep,
 	}
 }
 
+void rem_ctl(const http::server::request &req, http::server::reply &rep, boost::cmatch& grps){
+
+	std::string lsi_name;
+	std::string ctlid_str;
+	uint64_t dpid, ctl_id;
+
+	//Perform security checks
+	if(!authorised(req,rep)) return;
+
+	lsi_name = std::string(grps[1]);
+	ctlid_str = std::string(grps[2]);
+
+	//Check if LSI exists;
+        if(!switch_manager::exists_by_name(lsi_name)){
+                //Throw 404
+                std::stringstream ss;
+                ss<<"Invalid lsi '"<<lsi_name<<"'";
+                rep.content = ss.str();
+                rep.status = http::server::reply::not_found;
+                return;
+        }
+
+	// Get dpid
+	dpid = switch_manager::get_switch_dpid(lsi_name);
+
+	// get Ctlid
+	ctl_id = atoi(ctlid_str.c_str());
+	rofl::cctlid ctlid(ctl_id);
+
+	try{
+		switch_manager::disconnect_from_ctl(dpid, ctlid);
+	}catch(...){
+                throw "Unable to remove controller from lsi";
+	}
+}
+
 } //namespace delete
 } //namespace controllers
 } //namespace xdpd