GebrCommServer

GebrCommServer

Synopsis

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

Description

Details

GEBR_PORT_PREFIX

#define             GEBR_PORT_PREFIX

GEBR_ADDR_PREFIX

#define             GEBR_ADDR_PREFIX

enum GebrCommServerType

typedef enum {
	GEBR_COMM_SERVER_TYPE_MOAB,
	GEBR_COMM_SERVER_TYPE_REGULAR,
	GEBR_COMM_SERVER_TYPE_UNKNOWN
} GebrCommServerType;

enum GebrCommServerLocation

typedef enum {
	GEBR_COMM_SERVER_LOCATION_UNKNOWN,
	GEBR_COMM_SERVER_LOCATION_LOCAL,
	GEBR_COMM_SERVER_LOCATION_REMOTE
} GebrCommServerLocation;

gebr_comm_server_get_user ()

gchar *             gebr_comm_server_get_user           (const char *address);

gebr_comm_server_get_id ()

GebrCommServerType  gebr_comm_server_get_id             (const gchar *name);

enum GebrCommServerState

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

GebrCommServer

typedef struct {
	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,
} GebrCommServer;

GebrCommServerPriv

typedef struct _GebrCommServerPriv GebrCommServerPriv;

GebrCommServerClass

typedef struct {
	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);
} GebrCommServerClass;

log_message ()

void                (*log_message)                      (GebrCommServer *server,
                                                         GebrLogMessageType type,
                                                         const gchar *message,
                                                         gpointer user_data);

state_changed ()

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

process_request ()

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

process_response ()

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

parse_messages ()

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

gebr_comm_server_new ()

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

gebr_comm_server_get_last_error ()

const gchar *       gebr_comm_server_get_last_error     (GebrCommServer *server);

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_free ()

void                gebr_comm_server_free               (GebrCommServer *gebr_comm_server);

gebr_comm_server_connect ()

void                gebr_comm_server_connect            (GebrCommServer *server,
                                                         gboolean maestro,
                                                         gboolean force_init);

gebr_comm_server_disconnect ()

void                gebr_comm_server_disconnect         (GebrCommServer *gebr_comm_server);

gebr_comm_server_is_logged ()

gboolean            gebr_comm_server_is_logged          (GebrCommServer *gebr_comm_server);

gebr_comm_server_set_logged ()

void                gebr_comm_server_set_logged         (GebrCommServer *server);

gebr_comm_server_is_local ()

gboolean            gebr_comm_server_is_local           (GebrCommServer *gebr_comm_server);

gebr_comm_server_kill ()

void                gebr_comm_server_kill               (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_state_to_string ()

const gchar *       gebr_comm_server_state_to_string    (GebrCommServerState state);

gebr_comm_server_state_from_string ()

GebrCommServerState  gebr_comm_server_state_from_string (const gchar *string);

gebr_comm_server_get_state ()

GebrCommServerState  gebr_comm_server_get_state         (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_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_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_get_accepts_key ()

gboolean            gebr_comm_server_get_accepts_key    (GebrCommServer *server);

Return if the server accepts public key


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_set_use_public_key ()

void                gebr_comm_server_set_use_public_key (GebrCommServer *server,
                                                         gboolean use_key);

gebr_comm_server_get_use_public_key ()

gboolean            gebr_comm_server_get_use_public_key (GebrCommServer *server);

gebr_comm_server_is_maestro ()

gboolean            gebr_comm_server_is_maestro         (GebrCommServer *server);

gebr_comm_server_maestro_connect_on_daemons ()

void                gebr_comm_server_maestro_connect_on_daemons
                                                        (GebrCommServer *server);

gebr_comm_server_create_port_provider ()

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