GebrCommServer

GebrCommServer

Synopsis

#define             GEBR_ADDR_PREFIX
#define             GEBR_PORT_PREFIX
struct              GebrCommServer;
struct              GebrCommServerClass;
enum                GebrCommServerLocation;
                    GebrCommServerPriv;
enum                GebrCommServerState;
enum                GebrCommServerType;
void                gebr_comm_server_answer_question    (GebrCommServer *server,
                                                         gboolean response);
void                gebr_comm_server_append_key         (GebrCommServer *server,
                                                         void *finished_callback,
                                                         gpointer user_data);
void                gebr_comm_server_connect            (GebrCommServer *server,
                                                         gboolean maestro);
GebrCommPortProvider * gebr_comm_server_create_port_provider
                                                        (GebrCommServer *server,
                                                         GebrCommPortType type);
void                gebr_comm_server_disconnect         (GebrCommServer *gebr_comm_server);
void                gebr_comm_server_forward_x11        (GebrCommServer *gebr_comm_server);
void                gebr_comm_server_free               (GebrCommServer *gebr_comm_server);
gboolean            gebr_comm_server_get_accepts_key    (GebrCommServer *server);
GebrCommServerType  gebr_comm_server_get_id             (const gchar *name);
const gchar *       gebr_comm_server_get_last_error     (GebrCommServer *server);
GebrCommServerState gebr_comm_server_get_state          (GebrCommServer *server);
gboolean            gebr_comm_server_get_use_public_key (GebrCommServer *server);
gchar *             gebr_comm_server_get_user           (const char *address);
void                gebr_comm_server_invalid_password   (GebrCommServer *server);
gboolean            gebr_comm_server_is_local           (GebrCommServer *gebr_comm_server);
gboolean            gebr_comm_server_is_logged          (GebrCommServer *gebr_comm_server);
gboolean            gebr_comm_server_is_maestro         (GebrCommServer *server);
void                gebr_comm_server_kill               (GebrCommServer *gebr_comm_server);
void                gebr_comm_server_maestro_connect_on_daemons
                                                        (GebrCommServer *server);
GebrCommServer *    gebr_comm_server_new                (const gchar *_address,
                                                         const gchar *gebr_id,
                                                         gboolean need_cleanup,
                                                         const struct gebr_comm_server_ops *ops);
void                gebr_comm_server_set_last_error     (GebrCommServer *server,
                                                         enum gebr_comm_server_error error,
                                                         const gchar *message,
                                                         ...);
void                gebr_comm_server_set_logged         (GebrCommServer *server);
void                gebr_comm_server_set_password       (GebrCommServer *server,
                                                         const gchar *pass);
void                gebr_comm_server_set_use_public_key (GebrCommServer *server,
                                                         gboolean use_key);
GebrCommServerState gebr_comm_server_state_from_string  (const gchar *string);
const gchar *       gebr_comm_server_state_to_string    (GebrCommServerState state);

Description

Details

GEBR_ADDR_PREFIX

#define             GEBR_ADDR_PREFIX

GEBR_PORT_PREFIX

#define             GEBR_PORT_PREFIX

struct GebrCommServer

struct GebrCommServer {
	GObject parent;
	GebrCommProtocolSocket *socket;

	GebrCommServerPriv *priv;

	/* server address/port */
	GString *address;
	guint16 port;
	gboolean ac;

	/* ssh stuff */
	gboolean use_public_key;
	gchar *password;
	gint16 tunnel_port;
	GebrCommTerminalProcess *x11_forward_process;
	GebrCommProcess *x11_forward_unix;

	gint ncores;
	gdouble clock_cpu;
	gchar *memory;
	gchar *model_name;

	GebrCommServerState state;

	enum gebr_comm_server_error {
		SERVER_ERROR_UNKNOWN,
		SERVER_ERROR_NONE,
		SERVER_ERROR_CONNECT,
		SERVER_ERROR_SERVER,
		SERVER_ERROR_SSH,
		SERVER_ERROR_PROTOCOL_VERSION,
	} error;

	GString *last_error;

	/* virtual methods */
	const struct gebr_comm_server_ops {
		void     (*log_message)      (GebrCommServer *server,
					      GebrLogMessageType type,
					      const gchar *message,
					      gpointer user_data);

		void     (*state_changed)    (GebrCommServer *server,
					      gpointer user_data);

		void     (*process_request)  (GebrCommServer *server,
					      GebrCommHttpMsg *request,
					      gpointer user_data);

		void     (*process_response) (GebrCommServer *server,
					      GebrCommHttpMsg *request,
					      GebrCommHttpMsg *response,
					      gpointer user_data);

		void     (*parse_messages)   (GebrCommServer *server,
					      gpointer user_data);
	} *ops;
	gpointer user_data;

	GebrCommTerminalProcess *process;
};

struct GebrCommServerClass

struct GebrCommServerClass {
	GObjectClass parent_class;

	void (*server_password_request) (GebrCommServer *server,
					 const gchar *title,
				         const gchar *message);

	void (*question_request) (GebrCommServer *server,
				  const gchar *title,
				  const gchar *message);
};

enum GebrCommServerLocation

typedef enum {
	GEBR_COMM_SERVER_LOCATION_UNKNOWN,
	GEBR_COMM_SERVER_LOCATION_LOCAL,
	GEBR_COMM_SERVER_LOCATION_REMOTE
} GebrCommServerLocation;

GebrCommServerPriv

typedef struct _GebrCommServerPriv GebrCommServerPriv;

enum GebrCommServerState

typedef enum {
	SERVER_STATE_DISCONNECTED,
	SERVER_STATE_RUN,
	SERVER_STATE_CONNECT,
	SERVER_STATE_LOGGED,
} GebrCommServerState;

enum GebrCommServerType

typedef enum {
	GEBR_COMM_SERVER_TYPE_MOAB,
	GEBR_COMM_SERVER_TYPE_REGULAR,
	GEBR_COMM_SERVER_TYPE_UNKNOWN
} GebrCommServerType;

gebr_comm_server_answer_question ()

void                gebr_comm_server_answer_question    (GebrCommServer *server,
                                                         gboolean response);

Writes a response into server.

This method is similar to gebr_comm_server_set_password(), but it can only be called if a "question_request" signal was emitted. The response is the answer for a Yes or No question.


gebr_comm_server_append_key ()

void                gebr_comm_server_append_key         (GebrCommServer *server,
                                                         void *finished_callback,
                                                         gpointer user_data);

Append key in the server


gebr_comm_server_connect ()

void                gebr_comm_server_connect            (GebrCommServer *server,
                                                         gboolean maestro);

gebr_comm_server_create_port_provider ()

GebrCommPortProvider * gebr_comm_server_create_port_provider
                                                        (GebrCommServer *server,
                                                         GebrCommPortType type);

gebr_comm_server_disconnect ()

void                gebr_comm_server_disconnect         (GebrCommServer *gebr_comm_server);

gebr_comm_server_forward_x11 ()

void                gebr_comm_server_forward_x11        (GebrCommServer *gebr_comm_server);

Forward remote_display to the local machine.


gebr_comm_server_free ()

void                gebr_comm_server_free               (GebrCommServer *gebr_comm_server);

gebr_comm_server_get_accepts_key ()

gboolean            gebr_comm_server_get_accepts_key    (GebrCommServer *server);

Return if the server accepts public key


gebr_comm_server_get_id ()

GebrCommServerType  gebr_comm_server_get_id             (const gchar *name);

gebr_comm_server_get_last_error ()

const gchar *       gebr_comm_server_get_last_error     (GebrCommServer *server);

gebr_comm_server_get_state ()

GebrCommServerState gebr_comm_server_get_state          (GebrCommServer *server);

gebr_comm_server_get_use_public_key ()

gboolean            gebr_comm_server_get_use_public_key (GebrCommServer *server);

gebr_comm_server_get_user ()

gchar *             gebr_comm_server_get_user           (const char *address);

gebr_comm_server_invalid_password ()

void                gebr_comm_server_invalid_password   (GebrCommServer *server);

Set password error for all pending connections, and clean list after that.


gebr_comm_server_is_local ()

gboolean            gebr_comm_server_is_local           (GebrCommServer *gebr_comm_server);

gebr_comm_server_is_logged ()

gboolean            gebr_comm_server_is_logged          (GebrCommServer *gebr_comm_server);

gebr_comm_server_is_maestro ()

gboolean            gebr_comm_server_is_maestro         (GebrCommServer *server);

gebr_comm_server_kill ()

void                gebr_comm_server_kill               (GebrCommServer *gebr_comm_server);

gebr_comm_server_maestro_connect_on_daemons ()

void                gebr_comm_server_maestro_connect_on_daemons
                                                        (GebrCommServer *server);

gebr_comm_server_new ()

GebrCommServer *    gebr_comm_server_new                (const gchar *_address,
                                                         const gchar *gebr_id,
                                                         gboolean need_cleanup,
                                                         const struct gebr_comm_server_ops *ops);

gebr_comm_server_set_last_error ()

void                gebr_comm_server_set_last_error     (GebrCommServer *server,
                                                         enum gebr_comm_server_error error,
                                                         const gchar *message,
                                                         ...);

gebr_comm_server_set_logged ()

void                gebr_comm_server_set_logged         (GebrCommServer *server);

gebr_comm_server_set_password ()

void                gebr_comm_server_set_password       (GebrCommServer *server,
                                                         const gchar *pass);

Writes pass into server.

If server is in interactive mode (see gebr_comm_server_set_interactive()) then pass is written into server only if the signal "password-request" has been emitted.

Otherwise, if server is in noninteractive mode, the password is cached for the next connection, see gebr_comm_server_connect().


gebr_comm_server_set_use_public_key ()

void                gebr_comm_server_set_use_public_key (GebrCommServer *server,
                                                         gboolean use_key);

gebr_comm_server_state_from_string ()

GebrCommServerState gebr_comm_server_state_from_string  (const gchar *string);

gebr_comm_server_state_to_string ()

const gchar *       gebr_comm_server_state_to_string    (GebrCommServerState state);