void client::send_message()
{
if ( message_ )
{
if ( connected_ )
{
std::ostream stream( &request_ );
stream << message_->to_string();
//
boost::asio::async_write( socket_,
request_,
boost::bind( &client::handle_write_message,
this,
boost::asio::placeholders::error ) );
}
else
{
if ( --retry_ > 0 )
resolve();
else
on_error( boost::system::errc::make_error_code( boost::system::errc::not_connected ) );
}
}
else
on_error( boost::system::errc::make_error_code( boost::system::errc::no_message_available ) );
}
static int event_on_accept (struct event_data *self, struct kevent *event) {
struct sockaddr client;
socklen_t client_len = sizeof(client);
int client_fd = accept(server_fd, &client, &client_len);
int flags;
int err;
if (client_fd < 0) {
if (errno == EWOULDBLOCK || errno == EAGAIN) return 0;
on_error("Accept failed (should this be fatal?): %s\n", strerror(errno));
}
flags = fcntl(client_fd, F_GETFL, 0);
if (flags < 0) on_error("Could not get client socket flags: %s\n", strerror(errno));
err = fcntl(client_fd, F_SETFL, flags | O_NONBLOCK);
if (err < 0) on_error("Could not set client socket to be non blocking: %s\n", strerror(errno));
struct event_data *client_data = (struct event_data *) malloc(sizeof(struct event_data));
client_data->on_read = event_on_read;
client_data->on_write = event_on_write;
event_change(client_fd, EVFILT_READ, EV_ADD | EV_ENABLE, client_data);
event_change(client_fd, EVFILT_WRITE, EV_ADD | EV_ENABLE, client_data);
return 1;
}
void FileLoader::start_up() {
auto r_file_info = init();
if (r_file_info.is_error()) {
on_error(r_file_info.move_as_error());
stop_flag_ = true;
return;
}
auto file_info = r_file_info.ok();
auto size = file_info.size;
auto expected_size = max(size, file_info.expected_size);
bool is_size_final = file_info.is_size_final;
auto part_size = file_info.part_size;
auto &ready_parts = file_info.ready_parts;
auto use_part_count_limit = file_info.use_part_count_limit;
auto status = parts_manager_.init(size, expected_size, is_size_final, part_size, ready_parts, use_part_count_limit);
if (file_info.only_check) {
parts_manager_.set_checked_prefix_size(0);
}
if (status.is_error()) {
on_error(std::move(status));
stop_flag_ = true;
return;
}
if (ordered_flag_) {
ordered_parts_ = OrderedEventsProcessor<std::pair<Part, NetQueryPtr>>(parts_manager_.get_ready_prefix_count());
}
if (file_info.need_delay) {
delay_dispatcher_ = create_actor<DelayDispatcher>("DelayDispatcher", 0.003);
next_delay_ = 0.05;
}
resource_state_.set_unit_size(parts_manager_.get_part_size());
update_estimated_limit();
on_progress_impl(narrow_cast<size_t>(parts_manager_.get_ready_size()));
yield();
}
virtual void accept()
{
//Create new socket for this connection
//Shared_ptr is used to pass temporary objects to the asynchronous functions
auto socket = std::make_shared<HTTPS>(*io_service, context);
acceptor->async_accept((*socket).lowest_layer(), [this, socket](const boost::system::error_code &ec)
{
//Immediately start accepting a new connection (if io_service hasn't been stopped)
if (ec != boost::asio::error::operation_aborted)
accept();
if (!ec)
{
boost::asio::ip::tcp::no_delay option(true);
socket->lowest_layer().set_option(option);
//Set timeout on the following boost::asio::ssl::stream::async_handshake
auto timer = get_timeout_timer(socket, config.timeout_request);
socket->async_handshake(boost::asio::ssl::stream_base::server, [this, socket, timer]
(const boost::system::error_code &ec)
{
if (timer)
timer->cancel();
if (!ec)
read_request_and_content(socket);
else if (on_error)
on_error(std::shared_ptr<Request>(new Request(*socket)), ec);
});
}
else if (on_error)
on_error(std::shared_ptr<Request>(new Request(*socket)), ec);
});
}
void
IghtConnectionState::handle_event(bufferevent *bev, short what, void *opaque)
{
auto self = (IghtConnectionState *) opaque;
(void) bev; // Suppress warning about unused variable
if (self->connecting && self->closing) {
delete (self);
return;
}
if (what & BEV_EVENT_CONNECTED) {
self->connecting = 0;
self->on_connect();
return;
}
if (what & BEV_EVENT_EOF) {
self->on_error(IghtError(0));
return;
}
if (self->connecting) {
ight_info("connection::handle_event - try connect next");
self->connect_next();
return;
}
// TODO: also handle the timeout
self->on_error(IghtError(-1));
}
int FLUX::GCodeParser::handle_g0g1(const char* linep, int offset, int size) {
bool terminated = false;
uint8_t flags = 0;
float val;
while(offset < size && !terminated) {
if(move_to_next_char(linep, offset, size, &offset)) {
char param = linep[offset];
switch(param) {
case ';':
case '\n':
terminated = true;
break;
case 'E':
offset = parse_command_float(linep, offset, size, &val);
flags |= FLAG_HAS_E(T);
if(from_inch) { val = inch2mm(val); }
if(absolute) {
filaments[T] = val + filaments_offset[T];
} else {
filaments[T] += val + filaments_offset[T];
}
break;
case 'F':
offset = parse_command_float(linep, offset, size, &val);
if(flags & FLAG_HAS_FEEDRATE) { on_error(handler, false, "DULE_F"); }
flags |= FLAG_HAS_FEEDRATE;
feedrate = val;
break;
case 'X':
case 'Y':
case 'Z':
offset = parse_command_float(linep, offset, size, &val);
if(flags & FLAG_HAS_AXIS(param)) { on_error(handler, false, "DULE_%c", param); }
flags |= FLAG_HAS_AXIS(param);
int axis = param - 'X';
if(from_inch) { val = inch2mm(val); }
if(absolute) {
position[axis] = val + position_offset[axis];
} else {
position[axis] += val + position_offset[axis];
}
break;
}
} else {
break;
}
}
handler->moveto(flags, feedrate,
position[0], position[1], position[2],
filaments[0], filaments[1], filaments[2]);
return offset;
}
void FileLoader::update_local_file_location(const LocalFileLocation &local) {
auto r_prefix_info = on_update_local_location(local);
if (r_prefix_info.is_error()) {
on_error(r_prefix_info.move_as_error());
stop_flag_ = true;
return;
}
auto prefix_info = r_prefix_info.move_as_ok();
auto status = parts_manager_.set_known_prefix(narrow_cast<size_t>(prefix_info.size), prefix_info.is_ready);
if (status.is_error()) {
on_error(std::move(status));
stop_flag_ = true;
return;
}
loop();
}
void FileLoader::on_common_query(NetQueryPtr query) {
auto status = process_check_query(std::move(query));
if (status.is_error()) {
on_error(std::move(status));
stop_flag_ = true;
}
}
void FileLoader::on_part_query(Part part, NetQueryPtr query) {
auto status = try_on_part_query(part, std::move(query));
if (status.is_error()) {
on_error(std::move(status));
stop_flag_ = true;
}
}
/*
Read data until buffered_amount == 0 - then stop event loop!
*/
static neat_error_code
on_readable(struct neat_flow_operations *opCB)
{
// data is available to read
neat_error_code code;
if (config_log_level >= 2) {
fprintf(stderr, "%s()\n", __func__);
}
code = neat_read(opCB->ctx, opCB->flow, buffer, config_buffer_size, &buffer_filled, NULL, 0);
if (code != NEAT_OK) {
if (code == NEAT_ERROR_WOULD_BLOCK) {
if (config_log_level >= 1) {
printf("on_readable - NEAT_ERROR_WOULD_BLOCK\n");
}
return NEAT_OK;
} else {
fprintf(stderr, "%s - neat_read error: %d\n", __func__, (int)code);
return on_error(opCB);
}
}
if (config_log_level >= 1) {
printf("received data - %d byte\n", buffer_filled);
}
if (config_log_level >= 2) {
fwrite(buffer, sizeof(char), buffer_filled, stdout);
printf("\n");
fflush(stdout);
}
return NEAT_OK;
}
/*---------------------------------------------------------------------------*/
int lua_tinker::meta_get(lua_State *L)
{
lua_getmetatable(L,1);
lua_pushvalue(L,2);
lua_rawget(L,-2);
if(lua_isuserdata(L,-1))
{
user2type<var_base*>::invoke(L,-1)->get(L);
lua_remove(L, -2);
}
else if(lua_isnil(L,-1))
{
lua_remove(L,-1);
invoke_parent(L);
if(lua_isnil(L,-1))
{
lua_pushfstring(L, "can't find '%s' class variable. (forgot registering class variable ?)", lua_tostring(L, 2));
on_error(L);
}
}
lua_remove(L,-2);
return 1;
}
Light::Light()
{
QObject::connect(&m_connection, SIGNAL(connected()), SLOT(on_connected()));
QObject::connect(&m_connection, SIGNAL(error()), SLOT(on_error()));
QObject::connect(&m_connection, SIGNAL(disconnected()), SLOT(on_disconnected()));
QObject::connect(&m_connection, SIGNAL(readyRead()), SLOT(on_readyRead()));
}
void basic_async_logger<traits>::print_error(int a_errno, const char* a_what, int a_line) {
if (on_error)
on_error(a_errno, a_what);
else
std::cerr << "Error " << a_errno << " writing to file \"" << m_filename << "\": "
<< a_what << " [" << __FILE__ << ':' << a_line << ']' << std::endl;
}
void connection_mgr::on_connected() {
connected_sig();
auto self = shared_from_this();
m_connection->send_command("list_remotes", "" , [self] ( const bs::error_code &ec
, const std::string& status
, std::string& data ) {
bs::error_code _ec = ec;
if (!_ec && status != "k")
_ec = make_iks_error_code(data);
if (!_ec) {
std::vector<remote_entry> remotes;
if (self->parse_remotes(data, remotes))
for (auto& e : remotes)
self->connect_location(e.first, e.second);
else
_ec = make_error_code(iks_client_error::invalid_server_response);
}
if (_ec)
self->on_error(_ec);
return IksCmdStatus::cmd_done;
});
}
void client::handle_read_status_line( const boost::system::error_code& error )
{
if ( ! error )
{
// Check that response is OK.
std::istream stream( &reply_ );
std::string status;
if ( std::getline( stream, status ) )
{
if ( ! response_->set_status( status ) )
throw std::runtime_error( "Invalid status encountered: " + status );
}
// read the response headers, which are terminated by a blank line.
boost::asio::async_read_until( socket_,
reply_,
"\r\n\r\n",
boost::bind( &client::handle_read_headers,
this,
boost::asio::placeholders::error ) );
}
else
on_error( error );
}
//==============================================================================
bool USB_Device::open_by_vid_pid(uint16_t vendor_id, uint16_t product_id)
{
init_context();
close();
libusb_device_vector devices;
USB_Enumerator enumerator(context_, devices);
libusb_device_descriptor descriptor;
foreach (libusb_device *item, devices)
{
if (!libusb_get_device_descriptor(item, &descriptor) &&
descriptor.idVendor == vendor_id &&
descriptor.idProduct == product_id)
{
int result = libusb_open(item, &handle_);
if (result < 0)
on_error("libusb_open", result);
device_ = libusb_get_device(handle_);
log_info("usb, open device, VID: %04Xh, PID: %04Xh", vendor_id, product_id);
return true;
}
}
return false;
}
gboolean
qof_commit_edit_part2(QofInstance *inst,
void (*on_error)(QofInstance *, QofBackendError),
void (*on_done)(QofInstance *),
void (*on_free)(QofInstance *))
{
QofInstancePrivate *priv;
QofBackend * be;
gboolean dirty;
priv = GET_PRIVATE(inst);
dirty = priv->dirty;
/* See if there's a backend. If there is, invoke it. */
be = qof_book_get_backend(priv->book);
if (be && qof_backend_commit_exists(be))
{
QofBackendError errcode;
/* clear errors */
do
{
errcode = qof_backend_get_error(be);
}
while (ERR_BACKEND_NO_ERR != errcode);
qof_backend_run_commit(be, inst);
errcode = qof_backend_get_error(be);
if (ERR_BACKEND_NO_ERR != errcode)
{
/* XXX Should perform a rollback here */
priv->do_free = FALSE;
/* Push error back onto the stack */
qof_backend_set_error (be, errcode);
if (on_error)
on_error(inst, errcode);
return FALSE;
}
/* XXX the backend commit code should clear dirty!! */
priv->dirty = FALSE;
}
// if (dirty && qof_get_alt_dirty_mode() &&
// !(priv->infant && priv->do_free)) {
// qof_collection_mark_dirty(priv->collection);
// qof_book_mark_dirty(priv->book);
// }
priv->infant = FALSE;
if (priv->do_free)
{
if (on_free)
on_free(inst);
return TRUE;
}
if (on_done)
on_done(inst);
return TRUE;
}
void client::handle_read_headers( const boost::system::error_code& error )
{
if ( ! error )
{
// process the response headers.
std::istream stream( &reply_ );
std::string header;
while ( std::getline( stream, header) && header != "\r" )
response_->set_header( header );
// start reading content (what remains in buffer)
while ( reply_.size() > 0 )
{
std::string content;
while ( std::getline( stream, content ) )
response_->set_content( content );
}
// start reading remaining data until eof.
boost::asio::async_read( socket_,
reply_,
boost::asio::transfer_at_least( 1 ),
boost::bind( &client::handle_read_content,
this,
boost::asio::placeholders::error ) );
}
else
on_error( error );
}
bool
TrexDpPortEvent::on_core_reporting_in(int thread_id, bool status) {
/* mark sure no double signal */
if (m_signal.at(thread_id)) {
std::stringstream err;
err << "double signal detected on event id: " << m_event_id;
throw TrexException(err.str());
}
/* mark */
m_signal.at(thread_id) = true;
m_pending_cnt--;
/* if any core reported an error - mark as a failure */
if (!status) {
on_error(thread_id);
}
/* event occured */
if (m_pending_cnt == 0) {
on_event();
return true;
} else {
return false;
}
}
static int event_on_read (struct event_data *self, struct kevent *event) {
if (self->buffer_read == BUFFER_SIZE) {
event_change(event->ident, EVFILT_READ, EV_DISABLE, self);
return 0;
}
int n = read(event->ident, self->buffer + self->buffer_read, BUFFER_SIZE - self->buffer_read);
if (n < 0) {
if (errno == EWOULDBLOCK || errno == EAGAIN) return 0;
on_error("Read failed (should this be fatal?): %s\n", strerror(errno));
}
if (n == 0) {
free(self);
close(event->ident);
return 0;
}
if (self->buffer_read == 0) {
event_change(event->ident, EVFILT_WRITE, EV_ENABLE, self);
}
self->buffer_read += n;
return event_flush_write(self, event);
}
int FLUX::GCodeParser::handle_g28(const char* linep, int offset, int size) {
if(move_to_next_char(linep, offset, size, &offset)) {
on_error(handler, false, "G28_PARAM_IGNORED %.*s", size, linep);
}
handler->home();
return offset;
}
//==============================================================================
void USB_Device::set_configuration(uint_t configuration)
{
log_info("usb, set configuration %u", configuration);
int result = libusb_set_configuration(handle_, configuration);
if (result < 0)
on_error("set_configuration", result);
}
//==============================================================================
void USB_Device::release_interface(uint_t interface_number)
{
log_info("usb, release interface %u", interface_number);
int result = libusb_release_interface(handle_, interface_number);
if (result < 0)
on_error("release_interface", result);
}
//==============================================================================
void USB_Device::claim_interface(uint_t interface_number)
{
log_info("usb, claim interface %u", interface_number);
int result = libusb_claim_interface(handle_, interface_number);
if (result < 0)
on_error("claim_interface", result);
}
//==============================================================================
void USB_Device::device_decriptor(libusb_device_descriptor &descriptor)
{
check_open();
int result = libusb_get_device_descriptor(device_, &descriptor);
if (result != LIBUSB_SUCCESS)
on_error("Failed to get device descriptor", (libusb_error)result);
}
//==============================================================================
USB_Enumerator::USB_Enumerator(USB_ContextPtr context, libusb_device_vector &devices)
{
ssize_t count = libusb_get_device_list(context.get(), &list_);
if (count < 0)
on_error("libusb_get_device_list", count);
for (ssize_t i = 0; i < count; i++)
devices.push_back(list_[i]);
}
void MultipleRequestHandler::execute_query(const std::string& index, const std::string& query) {
if (has_errors_or_timeouts_) return;
responses_[index] = SharedRefPtr<Response>();
SharedRefPtr<InternalHandler> handler(new InternalHandler(this, new QueryRequest(query), index));
remaining_++;
if (!connection_->write(handler.get())) {
on_error(CASS_ERROR_LIB_NO_STREAMS, "No more streams available");
}
}
void on_invalid_char(char ch, const char *file, int line, int col)
{
if (ch == '\t')
on_error("Tabs not allowed in source text", file, line, col);
fprintf(stderr, "Invalid character '%c' (%d), in source text, file %s, line %d, column %d", (int) ch, (int) ch, file, line+1, col+1);
//fflush(stdout);
exit(-1);
}
void on_result(uint64 id, BufferSlice packet) override {
auto result_ptr = fetch_result<telegram_api::messages_getBotCallbackAnswer>(packet);
if (result_ptr.is_error()) {
return on_error(id, result_ptr.move_as_error());
}
td->callback_queries_manager_->on_get_callback_query_answer(result_id_, result_ptr.move_as_ok());
promise_.set_value(Unit());
}
bool CScriptStorage::do_file (LPCSTR caScriptName, LPCSTR caNameSpaceName)
{
int start = lua_gettop(lua());
string_path l_caLuaFileName;
IReader *l_tpFileReader = FS.r_open(caScriptName);
if (!l_tpFileReader) {
script_log (eLuaMessageTypeError,"Cannot open file \"%s\"",caScriptName);
return (false);
}
strconcat (sizeof(l_caLuaFileName),l_caLuaFileName,"@",caScriptName);
if (!load_buffer(lua(),static_cast<LPCSTR>(l_tpFileReader->pointer()),(size_t)l_tpFileReader->length(),l_caLuaFileName,caNameSpaceName)) {
// VERIFY (lua_gettop(lua()) >= 4);
// lua_pop (lua(),4);
// VERIFY (lua_gettop(lua()) == start - 3);
lua_settop (lua(),start);
FS.r_close (l_tpFileReader);
return (false);
}
FS.r_close (l_tpFileReader);
int errFuncId = -1;
#ifdef USE_DEBUGGER
# ifndef USE_LUA_STUDIO
if( ai().script_engine().debugger() )
errFuncId = ai().script_engine().debugger()->PrepareLua(lua());
# endif // #ifndef USE_LUA_STUDIO
#endif // #ifdef USE_DEBUGGER
if (0) //.
{
for (int i=0; lua_type(lua(), -i-1); i++)
Msg ("%2d : %s",-i-1,lua_typename(lua(), lua_type(lua(), -i-1)));
}
// because that's the first and the only call of the main chunk - there is no point to compile it
// luaJIT_setmode (lua(),0,LUAJIT_MODE_ENGINE|LUAJIT_MODE_OFF); // Oles
int l_iErrorCode = lua_pcall(lua(),0,0,(-1==errFuncId)?0:errFuncId); // new_Andy
// luaJIT_setmode (lua(),0,LUAJIT_MODE_ENGINE|LUAJIT_MODE_ON); // Oles
#ifdef USE_DEBUGGER
# ifndef USE_LUA_STUDIO
if( ai().script_engine().debugger() )
ai().script_engine().debugger()->UnPrepareLua(lua(),errFuncId);
# endif // #ifndef USE_LUA_STUDIO
#endif // #ifdef USE_DEBUGGER
if (l_iErrorCode) {
#ifdef DEBUG
print_output(lua(),caScriptName,l_iErrorCode);
#endif
on_error (lua());
lua_settop (lua(),start);
return (false);
}
return (true);
}
