HOT_INLINE hot_err_t hot_ens_Cast( hot_context_t s, hot_msg_t msg, hot_ens_MsgSendView *send_view /*OUT*/ ) { begin_write(); { begin_critical(); { if (s->leaving) { hot_sys_Panic("hot_ens_Cast: member is leaving") ; } if (send_view != NULL) { *send_view = (s->blocked) ? HOT_ENS_MSG_SEND_NEXT_VIEW : HOT_ENS_MSG_SEND_CURRENT_VIEW ; } } end_critical() ; /* Write the downcall. */ write_hdr(s,DN_CAST); write_msg(msg); } end_write(); return HOT_OK ; }
HOT_INLINE static void cb_Block( hot_contextID_t id, unsigned *cs ) { hot_context_t s; void *env; hot_ens_Block_cback block; begin_critical(); { s = lookup_context(id); env = s->env; block = s->conf.block; s->blocked = 1; } end_critical(); if (block != NULL) { (*block)(s, env); } /* Write the block_ok downcall. */ begin_write(); { write_hdr(s,DN_BLOCK_OK) ; } end_write(); }
bool SAS::Connection::connect_init() { int rc; struct sockaddr_in addr; LOG_STATUS("Attempting to connect to SAS %s", _sas_address.c_str()); if ((_sock = ::socket(AF_INET, SOCK_STREAM, 0)) == -1) { LOG_ERROR("Failed to open SAS socket: %d (%s)\n", errno, ::strerror(errno)); return false; } memset(&addr, 0, sizeof(addr)); addr.sin_family = AF_INET; addr.sin_port = htons(SAS_PORT); addr.sin_addr.s_addr = inet_addr(_sas_address.c_str()); rc = ::connect(_sock, (struct sockaddr*)&addr, sizeof(addr)); if (rc != 0) { LOG_ERROR("Failed to connect to SAS %s:%d : %d %s\n", _sas_address.c_str(), SAS_PORT, errno, ::strerror(errno)); ::close(_sock); return false; } LOG_DEBUG("Connected SAS socket to %s:%d", _sas_address.c_str(), SAS_PORT); // Send an init message to SAS. std::string init; std::string version("v0.1"); int init_len = INIT_HDR_SIZE + sizeof(uint8_t) + _system_name.length() + sizeof(uint32_t) + sizeof(uint8_t) + version.length(); init.reserve(init_len); write_hdr(init, init_len, SAS_MSG_INIT); write_int8(init, (uint8_t)_system_name.length()); write_data(init, _system_name.length(), _system_name.data()); int endianness = 1; init.append((char*)&endianness, sizeof(int)); // Endianness must be written in machine order. write_int8(init, version.length()); write_data(init, version.length(), version.data()); LOG_DEBUG("Sending SAS INIT message"); rc = ::send(_sock, init.data(), init.length(), 0); if (rc < 0) { LOG_ERROR("SAS connection to %s:%d failed: %d %s", _sas_address.c_str(), SAS_PORT, errno, ::strerror(errno)); return false; } LOG_STATUS("Connected to SAS %s:%d", _sas_address.c_str(), SAS_PORT); return true; }
/* Join a group. The group context is returned in *contextp. */ hot_err_t hot_ens_Join( hot_ens_JoinOps_t *jops, hot_context_t *contextp /*OUT*/ ) { hot_err_t err = HOT_OK ; hot_context_t s ; /* Initialize global state if not done so already. */ if (!g.initialized) { err = hot_ens_Init(jops->outboard, jops->argv); if (err != HOT_OK) return err; } begin_write(); { begin_critical(); { /* Allocate a new group context * Initialize the group record. */ s = alloc_context(); s->joining = 1 ; s->leaving = 0 ; s->conf = jops->conf; s->env = jops->env; s->view = NULL ; *contextp = s ; } end_critical(); /* Write the downcall. */ write_hdr(s,DN_JOIN); write_int(jops->heartbeat_rate); write_string(jops->transports); write_string(jops->protocol); write_string(jops->group_name); write_string(jops->properties); write_bool(jops->use_properties); write_bool(jops->groupd); write_string(jops->params); write_bool(jops->client); write_bool(jops->debug); if (jops->endpt.name[0] != 0x0) { hot_sys_Warning("HOT_OUTBOARD does not support 'endpt' in join ops") ; jops->endpt.name[0] = 0x0; } write_string(jops->princ); write_string(jops->key); write_bool(jops->secure); } end_write(); return HOT_OK; }
static void write_graph(Agraph_t * g, GVJ_t * job, int top, state_t* sp) { Agnode_t* np; Agedge_t* ep; int ncnt = 0; int ecnt = 0; int sgcnt = 0; int has_subgs; Dt_t* map; if (top) { map = dtopen (&intDisc, Dtoset); aginit(g, AGNODE, ID, sizeof(gvid_t), FALSE); aginit(g, AGEDGE, ID, sizeof(gvid_t), FALSE); aginit(g, AGRAPH, ID, -((int)sizeof(gvid_t)), FALSE); sgcnt = label_subgs(g, sgcnt, map); for (np = agfstnode(g); np; np = agnxtnode(g,np)) { if (IS_CLUSTER(np)) { ND_gid(np) = lookup(map, agnameof(np)); } else { ND_gid(np) = sgcnt + ncnt++; } for (ep = agfstout(g, np); ep; ep = agnxtout(g,ep)) { ED_gid(ep) = ecnt++; } } dtclose(map); } indent(job, sp->Level++); gvputs(job, "{\n"); write_hdr(g, job, top, sp); write_attrs((Agobj_t*)g, job, sp); if (top) { gvputs(job, ",\n"); indent(job, sp->Level); gvprintf(job, "\"_subgraph_cnt\": %d", sgcnt); } else { gvputs(job, ",\n"); indent(job, sp->Level); gvprintf(job, "\"_gvid\": %d", GD_gid(g)); } has_subgs = write_subgs(g, job, top, sp); write_nodes (g, job, top, has_subgs, sp); write_edges (g, job, top, sp); gvputs(job, "\n"); sp->Level--; indent(job, sp->Level); if (top) gvputs(job, "}\n"); else gvputs(job, "}"); }
/* Request a Rekey operation. */ hot_err_t hot_ens_Rekey( hot_context_t s ) { begin_write(); { begin_critical(); { if (s->leaving) { hot_sys_Panic("hot_ens_Rekey: member is leaving") ; } } end_critical(); write_hdr(s,DN_REKEY); } end_write(); return HOT_OK; }
/* Request a new view to be installed. */ hot_err_t hot_ens_RequestNewView( hot_context_t s ) { begin_write(); { begin_critical(); { if (s->leaving) { hot_sys_Panic("hot_ens_RequestNewView: member is leaving") ; } } end_critical(); write_hdr(s,DN_PROMPT); } end_write(); return HOT_OK; }
/* Inform Ensemble that the state-transfer is complete. */ hot_err_t hot_ens_XferDone( hot_context_t s ) { begin_write(); { begin_critical(); { if (s->leaving) { hot_sys_Panic("hot_ens_XferDone: member is leaving") ; } } end_critical(); write_hdr(s,DN_XFERDONE); } end_write(); return HOT_OK; }
HOT_INLINE hot_err_t hot_ens_Send( hot_context_t s, hot_endpt_t *dest, hot_msg_t msg, hot_ens_MsgSendView *send_view /*OUT*/ ) { begin_write(); { begin_critical(); { if (s->leaving) { hot_sys_Panic("hot_ens_Send: member is leaving") ; } if (send_view != NULL) { *send_view = (s->blocked) ? HOT_ENS_MSG_SEND_NEXT_VIEW : HOT_ENS_MSG_SEND_CURRENT_VIEW ; } } end_critical() ; if (s->blocked) { write_hdr(s,DN_SEND_BLOCKED); write_endpID(dest); write_msg(msg); } else { unsigned i ; begin_critical(); { for (i=0;i<s->nmembers;i++) { if (!strcmp(s->view[i].name,dest->name)) break ; } assert(i<s->nmembers) ; } end_critical() ; write_hdr(s,DN_SEND); write_int(i); write_msg(msg); } } end_write(); return HOT_OK; }
void SAS::associate_trails(TrailId trail_a, TrailId trail_b, Marker::Scope scope) { std::string trail_assoc_msg; write_hdr(trail_assoc_msg, 29, SAS_MSG_TRAIL_ASSOC, get_current_timestamp()); write_trail(trail_assoc_msg, trail_a); write_trail(trail_assoc_msg, trail_b); write_int8(trail_assoc_msg, (uint8_t)scope); if (_connection) { _connection->send_msg(trail_assoc_msg); } }
/* Request a protocol change specifying properties. */ hot_err_t hot_ens_ChangeProperties( hot_context_t s, char *properties ) { assert(properties) ; begin_write(); { begin_critical(); { if (s->leaving) { hot_sys_Panic("hot_ens_ChangeProperties: member is leaving") ; } } end_critical(); write_hdr(s,DN_PROPERTIES); write_string(properties); } end_write(); return HOT_OK; }
/* Request a protocol change. */ hot_err_t hot_ens_ChangeProtocol( hot_context_t s, char *protocol ) { assert(protocol); begin_write(); { begin_critical(); { if (s->leaving) { hot_sys_Panic("hot_ens_ChangeProtocol: member is leaving") ; } } end_critical(); write_hdr(s,DN_PROTOCOL); write_string(protocol); } end_write(); return HOT_OK; }
/* Report group members as failure-suspected. * * NB: In the initial implementation, this downcall will not be supported. * (if invoked, an exeption will be raised by OCAML). */ hot_err_t hot_ens_Suspect( hot_context_t s, hot_endpt_t *suspects, int nsuspects ) { begin_write(); { begin_critical(); { if (s->leaving) { hot_sys_Panic("hot_ens_Suspect: member is leaving") ; } } end_critical(); write_hdr(s,DN_SUSPECT); write_endpList(nsuspects, suspects); } end_write(); return HOT_OK; }
/* Leave a group. This should be the last call made to a given context. * No more events will be delivered to this context after the call * returns. */ hot_err_t hot_ens_Leave( hot_context_t s ) { begin_write(); { begin_critical(); { if (s->leaving) { hot_sys_Panic("hot_ens_Leave:this member is already leaving") ; } s->leaving = 1 ; } end_critical(); /* Write the downcall. */ write_hdr(s,DN_LEAVE); } end_write(); return HOT_OK; }
bool SAS::Connection::connect_init() { if (_socket_callback) { _sock = _socket_callback(_sas_address.c_str(), SAS_PORT); } else { _sock = get_local_sock(_sas_address.c_str(), SAS_PORT); } if (_sock < 0) { return false; } SAS_LOG_DEBUG("Connected SAS socket to %s:%s", _sas_address.c_str(), SAS_PORT); set_send_timeout(_sock, SEND_TIMEOUT); // Send an init message to SAS. std::string init; std::string version("v0.1"); // The resource version is part of the binary protocol but is not currently // exposed over the C++ API. std::string resource_version(""); int init_len = INIT_HDR_SIZE + sizeof(uint8_t) + _system_name.length() + sizeof(uint32_t) + sizeof(uint8_t) + version.length() + sizeof(uint8_t) + _system_type.length() + sizeof(uint8_t) + _resource_identifier.length() + sizeof(uint8_t) + resource_version.length(); init.reserve(init_len); write_hdr(init, init_len, SAS_MSG_INIT, get_current_timestamp()); write_int8(init, (uint8_t)_system_name.length()); write_data(init, _system_name.length(), _system_name.data()); int endianness = 1; init.append((char*)&endianness, sizeof(int)); // Endianness must be written in machine order. write_int8(init, version.length()); write_data(init, version.length(), version.data()); write_int8(init, (uint8_t)_system_type.length()); write_data(init, _system_type.length(), _system_type.data()); write_int8(init, (uint8_t)_resource_identifier.length()); write_data(init, _resource_identifier.length(), _resource_identifier.data()); write_int8(init, (uint8_t)resource_version.length()); write_data(init, resource_version.length(), resource_version.data()); SAS_LOG_DEBUG("Sending SAS INIT message"); int rc = ::send(_sock, init.data(), init.length(), 0); if (rc < 0) { SAS_LOG_ERROR("SAS connection to %s:%s failed: %d %s", _sas_address.c_str(), SAS_PORT, errno, ::strerror(errno)); ::close(_sock); _sock = -1; return false; } SAS_LOG_STATUS("Connected to SAS %s:%s", _sas_address.c_str(), SAS_PORT); return true; }