Initial commit (469023ff) · Commits · IA2 / tango_tools

README.md

0 → 100644

+19 −0

Original line number	Diff line number	Diff line
		# Tango Tools

		This repository stores some useful tools to manage your Tango installation.


		## Command line tools for Astor, Atk and Jive

		These are command line tools for Astor, Atk and Jive.

		To compile and install a tool, just enter the directory and run

		make
		sudo make install


		## Tango Service Scripts

		The directory `tango_demons` stores the service scripts `tango_databaseds` and `tango-starter`
		you may want to use to run Tango.

astor_cli/Makefile

0 → 100644

+77 −0

Original line number	Diff line number	Diff line
		#================================================================================
		EXEC_NAME :=astorcli
		INSTALL_DIR=/usr/local/bin
		RUN_ARGS :=
		INC_DIR=/usr/local/omniORB/include \
		/usr/local/zeromq/include/zmq \
		/usr/local/tango/include/tango \
		./src
		LIB_DIR=/usr/local/omniORB/lib \
		/usr/local/zeromq/lib \
		/usr/local/tango/lib
		#================================================================================
		CC := g++
		DEBUGFLAGS := -g
		CXXFLAGS := -c -Wall -Wextra -std=c++0x
		LDFLAGS := -Wall -lomniORB4 -lomniDynamic4 -lCOS4 -lomnithread -ltango -llog4tango
		INC_PARM := $(foreach d, $(INC_DIR), -I$d)
		LIB_PARM := $(foreach d, $(LIB_DIR), -L$d)
		#================================================================================
		SRC_DIR :=./src
		OBJ_DIR :=./obj
		BIN_DIR :=./bin
		#================================================================================
		EXECUTABLE := $(BIN_DIR)/$(EXEC_NAME)
		CPP_FILES := $(wildcard $(SRC_DIR)/*.cpp)
		OBJ_FILES := $(addprefix $(OBJ_DIR)/,$(notdir $(CPP_FILES:.cpp=.o)))
		#================================================================================

		all: CXXFLAGS += $(DEBUGFLAGS)
		all: $(EXECUTABLE)

		release: $(EXECUTABLE)
		-strip $(EXECUTABLE)

		run: CXXFLAGS += $(DEBUGFLAGS)
		run: $(EXECUTABLE)
		$(EXECUTABLE) $(RUN_ARGS)

		$(EXECUTABLE): makedir $(OBJ_FILES)
		$(CC) $(LDFLAGS) $(LIB_PARM) -o $@ $(OBJ_FILES)

		$(OBJ_DIR)/%.o: $(SRC_DIR)/%.cpp
		$(CC) $(CXXFLAGS) $(INC_PARM) -o $@ $<

		.PHONY: makedir
		makedir:
		-mkdir -p $(OBJ_DIR) $(BIN_DIR)

		.PHONY: clean
		clean:
		-rm -rf $(OBJ_DIR) $(BIN_DIR)

		.PHONY: install
		install:
		-cp $(EXECUTABLE) $(INSTALL_DIR)


		.PHONY: echo
		echo:
		@echo "----------------------------------------"
		@echo Source files
		@echo "----------------------------------------"
		@$(foreach file, $(CPP_FILES), echo "$(file)";)
		@echo "----------------------------------------"
		@echo Object files
		@echo "----------------------------------------"
		@$(foreach file, $(OBJ_FILES), echo "$(file)";)
		@echo "----------------------------------------"
		@echo Include paths
		@echo "----------------------------------------"
		@$(foreach parm, $(INC_PARM), echo "$(parm)";)
		@echo "----------------------------------------"
		@echo Linker paths
		@echo "----------------------------------------"
		@$(foreach parm, $(LIB_PARM), echo "$(parm)";)
		@echo "----------------------------------------"

astor_cli/src/main.cpp

0 → 100644

+248 −0

Original line number	Diff line number	Diff line
		#include <tango.h>
		#include <iomanip>
		#include <cstring>
		#include "proxy.hpp"

		//==============================================================================
		//Print menu
		//==============================================================================
		void print_help()
		{
		std::cout << "AstorCLI - Tango Astor Command LIne - v0.1"
		<< std::endl << std::endl;

		std::cout << "Usage: astorcli {command} [arguments]"
		<< std::endl << std::endl;

		std::cout << "Commands:" << std::endl;

		std::cout << " --help -> print this message" << std::endl;

		std::cout << " --hosts -> print hosts list" << std::endl;

		std::cout << " --servers {hostname} -> "
		"print servers info for a specified host" << std::endl;

		std::cout << " --running {hostname} {controlled} -> "
		"print running servers for a specified host" << std::endl;

		std::cout << " --stopped {hostname} {controlled} -> "
		"print stopped servers for a specified host" << std::endl;

		std::cout << " --start {hostname} {server} -> "
		"start server on a specified host" << std::endl;

		std::cout << " --stop {hostname} {server} -> "
		"stop server on a specified host" << std::endl;

		std::cout << " --kill {hostname} {server} -> "
		"kill server on a specified host" << std::endl;

		std::cout << " --get_info {server} -> "
		"print server info" << std::endl;

		std::cout << " --save_info {server} {hostname} {controlled} {startup} -> "
		"save server info" << std::endl << std::endl;

		std::cout << "Arguments:" << std::endl;

		std::cout << " server -> server_name/instance " << std::endl;

		std::cout << " hostname -> host name where server is registered"
		<< std::endl;

		std::cout << " controlled -> server startup is controlled by Starter"
		<< std::endl;

		std::cout << " startup -> server Starter startup level"
		<< std::endl << std::endl;
		}

		//==============================================================================
		//Main code
		//==============================================================================
		int main(int argc, char* argv[])
		{
		if(argc < 2)
		{
		std::cerr << "astorcli: missing command operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		std::string command = argv[1];

		astor_cli::proxy p;

		if(command.compare("--help")==0)
		{
		print_help();
		}
		else if(command.compare("--hosts")==0)
		{
		p.get_host_list();
		}
		else if(command.compare("--servers")==0)
		{
		if(argc < 3)
		{
		std::cerr << "astorcli: missing argument operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		std::string host_name = argv[2];

		p.get_host_servers_info(host_name);
		}
		else if(command.compare("--running")==0)
		{
		if(argc < 4)
		{
		std::cerr << "astorcli: missing argument operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		std::string host_name = argv[2];

		if(strcmp(argv[3], "0") != 0 && strcmp(argv[3], "1") != 0)
		{
		std::cerr << "astorcli: wrong argument operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		bool controlled;
		std::istringstream(argv[3]) >> controlled;

		p.get_host_running_servers(host_name, !controlled);
		}
		else if(command.compare("--stopped")==0)
		{
		if(argc < 4)
		{
		std::cerr << "astorcli: missing argument operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		std::string host_name = argv[2];

		if(strcmp(argv[3], "0") != 0 && strcmp(argv[3], "1") != 0)
		{
		std::cerr << "astorcli: wrong argument operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		bool controlled;
		std::istringstream(argv[3]) >> controlled;

		p.get_host_stopped_servers(host_name, !controlled);

		}
		else if(command.compare("--start")==0)
		{
		if(argc < 4)
		{
		std::cerr << "astorcli: missing argument operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		std::string host_name = argv[2];

		std::string server_name = argv[3];

		p.start_host_server(host_name, server_name);
		}
		else if(command.compare("--stop")==0)
		{
		if(argc < 4)
		{
		std::cerr << "astorcli: missing argument operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		std::string host_name = argv[2];

		std::string server_name = argv[3];

		p.stop_host_server(host_name, server_name);
		}
		else if(command.compare("--kill")==0)
		{
		if(argc < 4)
		{
		std::cerr << "astorcli: missing argument operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		std::string host_name = argv[2];

		std::string server_name = argv[3];

		p.kill_host_server(host_name, server_name);
		}
		else if(command.compare("--get_info")==0)
		{
		if(argc < 3)
		{
		std::cerr << "astorcli: missing argument operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		std::string server_name = argv[2];

		p.get_server_info(server_name);
		}
		else if(command.compare("--save_info")==0)
		{
		if(argc < 6)
		{
		std::cerr << "astorcli: missing argument operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		std::string server_name = argv[2];

		std::string host_name = argv[3];

		if(strcmp(argv[4], "0") != 0 && strcmp(argv[4], "1") != 0)
		{
		std::cerr << "astorcli: wrong argument operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		bool controlled;
		std::istringstream(argv[4]) >> controlled;

		if(strcmp(argv[5], "0") != 0 && strcmp(argv[5], "1") != 0 &&
		strcmp(argv[5], "2") != 0 && strcmp(argv[5], "3") != 0 &&
		strcmp(argv[5], "4") != 0 && strcmp(argv[5], "5") != 0)
		{
		std::cerr << "astorcli: wrong argument operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		int startup;
		std::istringstream(argv[5]) >> startup;

		p.put_server_info(server_name, host_name, controlled, startup);
		}
		else
		{
		std::cerr << "astorcli: wrong command operand" << std::endl
		<< "Try \'astorcli --help\' for more information" << std::endl;
		return 1;
		}

		return 0;
		}

astor_cli/src/proxy.cpp

0 → 100644

+347 −0

Original line number	Diff line number	Diff line
		#include <proxy.hpp>
		#include <iomanip>

		namespace astor_cli
		{

		//==============================================================================
		// proxy::get_host_list()
		//==============================================================================
		void proxy::get_host_list()
		{
		try
		{
		device_proxy_p = new Tango::DeviceProxy(databased_name);

		std::string filter = "*";

		Tango::DeviceData argin;
		argin << filter;

		Tango::DeviceData argout =
		device_proxy_p->command_inout("DbGetHostList", argin);

		if(!argout.is_empty())
		{
		const Tango::DevVarStringArray* hosts;
		argout >> hosts;

		if(hosts->length() != 0)
		{
		std::cout << "Number\tHost" << std::endl;

		for(unsigned int i=0; i<hosts->length(); ++i)
		std::cout << "[" << i << "]\t" << (*hosts)[i] << std::endl;
		}
		else
		std::cout << "No host found" << std::endl;
		}
		else
		std::cerr << "Error retrieving data" << std::endl;
		}
		catch(Tango::DevFailed& ex)
		{
		print_exception(ex);
		}
		}

		//==============================================================================
		// proxy::get_host_servers_info()
		//==============================================================================
		void proxy::get_host_servers_info(std::string host_name)
		{
		try
		{
		device_proxy_p = new Tango::DeviceProxy(databased_name);

		Tango::DeviceData argin;
		argin << host_name;

		Tango::DeviceData argout =
		device_proxy_p->command_inout("DbGetHostServersInfo", argin);

		if(!argout.is_empty())
		{
		const Tango::DevVarStringArray* servers_info;
		argout >> servers_info;

		if(servers_info->length() != 0)
		{
		int count = 0;

		std::cout << "Number\t" << std::left
		<< std::setw(40) << "Server"
		<< std::setw(11) << "Controlled"
		<< std::setw(6) << "Level" << std::endl;

		for(unsigned int i=0; i<servers_info->length(); i=i+3)
		{
		std::cout << "[" << count++ << "]\t" << std::left
		<< std::setw(40) << (*servers_info)[i]
		<< std::setw(11) << (*servers_info)[i+1]
		<< std::setw(6) << (*servers_info)[i+2] << std::endl;
		}
		}
		else
		std::cout << "No server found" << std::endl;
		}
		else
		std::cerr << "Error retrieving data" << std::endl;
		}
		catch(Tango::DevFailed& ex)
		{
		print_exception(ex);
		}
		}

		//==============================================================================
		// proxy::get_host_running_servers())
		//==============================================================================
		void proxy::get_host_running_servers(std::string host_name, bool controlled)
		{
		starter_name.append(host_name);

		try
		{
		device_proxy_p = new Tango::DeviceProxy(starter_name);

		Tango::DeviceData argin;
		argin << controlled;

		Tango::DeviceData argout =
		device_proxy_p->command_inout("DevGetRunningServers", argin);

		if(!argout.is_empty())
		{
		const Tango::DevVarStringArray* servers;
		argout >> servers;

		if(servers->length() != 0)
		{
		std::cout << "Number\tServers" << std::endl;

		for(unsigned int i=0; i<servers->length(); ++i)
		std::cout << "[" << i << "]\t" << (*servers)[i] << std::endl;
		}
		else
		std::cout << "No server found" << std::endl;
		}
		else
		std::cerr << "Error retrieving data" << std::endl;
		}
		catch(Tango::DevFailed& ex)
		{
		print_exception(ex);
		}
		}

		//==============================================================================
		// proxy::get_host_stopped_servers())
		//==============================================================================
		void proxy::get_host_stopped_servers(std::string host_name, bool controlled)
		{
		starter_name.append(host_name);

		try
		{
		device_proxy_p = new Tango::DeviceProxy(starter_name);

		Tango::DeviceData argin;
		argin << controlled;

		Tango::DeviceData argout =
		device_proxy_p->command_inout("DevGetStopServers", argin);

		if(!argout.is_empty())
		{
		const Tango::DevVarStringArray* servers;
		argout >> servers;

		if(servers->length() != 0)
		{
		std::cout << "Number\tServers" << std::endl;

		for(unsigned int i=0; i<servers->length(); ++i)
		std::cout << "[" << i << "]\t" << (*servers)[i] << std::endl;
		}
		else
		std::cout << "No server found" << std::endl;
		}
		else
		std::cerr << "Error retrieving data" << std::endl;
		}
		catch(Tango::DevFailed& ex)
		{
		print_exception(ex);
		}
		}

		//==============================================================================
		// proxy::start_host_server()
		//==============================================================================
		void proxy::start_host_server(std::string host_name, std::string server_name)
		{
		starter_name.append(host_name);

		try
		{
		device_proxy_p = new Tango::DeviceProxy(starter_name);

		Tango::DeviceData argin;
		argin << server_name;

		device_proxy_p->command_inout("DevStart", argin);
		}
		catch(Tango::DevFailed& ex)
		{
		print_exception(ex);
		}
		}

		//==============================================================================
		// proxy::stop_host_server()
		//==============================================================================
		void proxy::stop_host_server(std::string host_name, std::string server_name)
		{
		starter_name.append(host_name);

		try
		{
		device_proxy_p = new Tango::DeviceProxy(starter_name);

		Tango::DeviceData argin;
		argin << server_name;

		device_proxy_p->command_inout("DevStop", argin);
		}
		catch(Tango::DevFailed& ex)
		{
		print_exception(ex);
		}
		}

		//==============================================================================
		// proxy::kill_host_server()
		//==============================================================================
		void proxy::kill_host_server(std::string host_name, std::string server_name)
		{
		starter_name.append(host_name);

		try
		{
		device_proxy_p = new Tango::DeviceProxy(starter_name);

		Tango::DeviceData argin;
		argin << server_name;

		device_proxy_p->command_inout("HardKillServer", argin);
		}
		catch(Tango::DevFailed& ex)
		{
		print_exception(ex);
		}
		}

		//==============================================================================
		// proxy::get_server_info()
		//==============================================================================
		void proxy::get_server_info(std::string server_name)
		{
		try
		{
		device_proxy_p = new Tango::DeviceProxy(databased_name);

		Tango::DeviceData argin;
		argin << server_name;

		Tango::DeviceData argout =
		device_proxy_p->command_inout("DbGetServerInfo", argin);

		if(!argout.is_empty())
		{
		const Tango::DevVarStringArray* servers_info;
		argout >> servers_info;

		int count = 0;

		std::cout << "Number\t" << std::left
		<< std::setw(40) << "Server"
		<< std::setw(20) << "Host"
		<< std::setw(11) << "Controlled"
		<< std::setw(6) << "Level" << std::endl;

		if(servers_info->length()==4)
		{
		std::cout << "[" << count++ << "]\t" << std::left
		<< std::setw(40) << (*servers_info)[0]
		<< std::setw(20) << (*servers_info)[1]
		<< std::setw(11) << (*servers_info)[2]
		<< std::setw(6) << (*servers_info)[3] << std::endl;
		}
		else
		std::cerr << "Not enough info retrieved" << std::endl;
		}
		else
		std::cerr << "Error retrieving data" << std::endl;
		}
		catch(Tango::DevFailed& ex)
		{
		print_exception(ex);
		}
		}

		//==============================================================================
		// proxy::put_server_info()
		//==============================================================================
		void proxy::put_server_info(std::string server_name, std::string host_name,
		unsigned int controlled, unsigned int startup)
		{
		if(server_name.empty())
		{
		std::cerr << "Empty server name!" << std::endl;
		return;
		}

		if(host_name.empty())
		{
		std::cerr << "Empty host name!" << std::endl;
		return;
		}

		if(controlled > 1)
		{
		std::cerr << "Invalid controlled value, valid [0,1]" << std::endl;
		return;
		}

		if(startup > 5)
		{
		std::cerr << "Invalid startup level value, valid [0-5]" << std::endl;
		return;
		}

		Tango::DevVarStringArray* servers_info = new Tango::DevVarStringArray();
		servers_info->length(4);

		(*servers_info)[0] = CORBA::string_dup(server_name.c_str());
		(*servers_info)[1] = CORBA::string_dup(host_name.c_str());
		(*servers_info)[2] = CORBA::string_dup(int_to_string(controlled).c_str());
		(*servers_info)[3] = CORBA::string_dup(int_to_string(startup).c_str());

		try
		{
		device_proxy_p = new Tango::DeviceProxy(databased_name);

		Tango::DeviceData argin;
		argin << servers_info;

		device_proxy_p->command_inout("DbPutServerInfo", argin);
		}
		catch(Tango::DevFailed& ex)
		{
		print_exception(ex);
		}
		}

		} //namespace
		No newline at end of file

astor_cli/src/proxy.hpp

0 → 100644

+114 −0

Original line number	Diff line number	Diff line
		/*
		* File: proxy.hpp
		* Author: mdm
		*
		* Created on May 2, 2014, 3:18 PM
		*/

		#ifndef PROXY_HPP
		#define PROXY_HPP

		#include <tango.h>

		namespace astor_cli
		{

		class proxy
		{
		public:
		//------------------------------------------------------------------------------
		// Constructor and destructor
		//------------------------------------------------------------------------------
		proxy()
		{
		databased_name = "sys/database/2";
		starter_name = "tango/admin/";
		device_proxy_p = 0;
		}

		~proxy()
		{
		if(device_proxy_p)
		delete device_proxy_p;
		}

		//------------------------------------------------------------------------------
		// Get host list
		//------------------------------------------------------------------------------
		void get_host_list();

		//------------------------------------------------------------------------------
		// Get host servers info list
		//------------------------------------------------------------------------------
		void get_host_servers_info(std::string host_name);

		//------------------------------------------------------------------------------
		// Get host running and stopped server
		//------------------------------------------------------------------------------
		void get_host_running_servers(std::string host_name, bool controlled);

		void get_host_stopped_servers(std::string host_name, bool controlled);

		//------------------------------------------------------------------------------
		// Start stop and kill server on host
		//------------------------------------------------------------------------------
		void start_host_server(std::string host_name, std::string server_name);

		void stop_host_server(std::string host_name, std::string server_name);

		void kill_host_server(std::string host_name, std::string server_name);

		//------------------------------------------------------------------------------
		// Get and set server starter info
		//------------------------------------------------------------------------------
		void get_server_info(std::string server_name);

		void put_server_info(std::string server_name, std::string host_name,
		unsigned int controlled, unsigned int startup);

		protected:
		//------------------------------------------------------------------------------
		// Exception handling methods
		//------------------------------------------------------------------------------
		void print_exception(Tango::DevFailed& ex)
		{
		std::stringstream error_msg;

		for(unsigned int i = 0; i < ex.errors.length(); ++i)
		{
		error_msg << ex.errors[i].reason.in() << std::endl;
		error_msg << ex.errors[i].desc.in() << std::endl;
		error_msg << ex.errors[i].origin.in() << std::endl;
		}

		std::cerr << "Error: " << error_msg.str() << std::endl;
		}

		//------------------------------------------------------------------------------
		// Unsigned integer to string conversion method
		//------------------------------------------------------------------------------
		std::string int_to_string(unsigned int value)
		{
		std::stringstream conversion;
		conversion << value;

		return conversion.str();
		}

		//------------------------------------------------------------------------------
		// Class variables
		//------------------------------------------------------------------------------
		//Tango database device name
		std::string databased_name;

		//Tango starter device partial name
		std::string starter_name;

		//Tango device proxy pointer
		Tango::DeviceProxy* device_proxy_p;
		};

		} //namespace

		#endif /* PROXY_HPP */