8 #ifdef _MADARA_PYTHON_CALLBACKS_ 10 #include <boost/python/call.hpp> 18 #include "madara_jni.h" 61 "KnowledgeRecordFilters::add: " 62 "Adding C record filter\n");
65 for (uint32_t cur = 1; types > 0; cur <<= 1)
90 "KnowledgeRecordFilters::add: " 91 "Adding C aggregate filter\n");
106 "KnowledgeRecordFilters::add: " 107 "Adding aggregate functor filter\n");
122 "KnowledgeRecordFilters::add: " 123 "Adding buffer functor filter\n");
139 "KnowledgeRecordFilters::add: " 140 "Adding record function filter to types\n");
143 for (uint32_t cur = 1; types > 0; cur <<= 1)
164 if (callable != NULL)
169 "KnowledgeRecordFilters::add: " 170 "Adding Java record filter\n");
173 for (uint32_t cur = 1; types > 0; cur <<= 1)
192 if (callable != NULL)
197 "KnowledgeRecordFilters::add: " 198 "Adding Java aggregate filter\n");
206 #ifdef _MADARA_PYTHON_CALLBACKS_ 210 boost::python::object & callable)
212 if (!callable.is_none ())
215 for (uint32_t cur = 1; types > 0; cur <<= 1)
232 boost::python::object & callable)
234 if (!callable.is_none ())
253 for (uint32_t cur = 1; types > 0; cur <<= 1)
290 "Printing Knowledge Record Filter Chains by Type...\n");
292 for (FilterMap::const_iterator i =
filters_.begin ();
298 "%d = %d chained filters\n", i->first, i->second.size ());
322 FilterMap::const_iterator type_match =
filters_.find (type);
331 "KnowledgeRecordFilters::filter: " 332 "Entering record filter logic\n");
338 std::unique_ptr <Variables> heap_variables (
341 heap_variables->context_ =
context_;
343 for (FilterChain::const_iterator i = chain.begin ();
344 i != chain.end (); ++i)
349 "KnowledgeRecordFilters::filter: " 350 "Preparing args for filter\n");
362 arguments[1].set_value (name);
386 arguments[7].set_value (transport_context.
get_domain ());
392 arguments[0] = result;
397 "KnowledgeRecordFilters::filter: " 398 "Checking filter type\n");
401 if (i->is_functor ())
406 "KnowledgeRecordFilters::filter: " 407 "Calling functor filter\n");
409 result = i->functor->filter (arguments, *heap_variables.get ());
412 else if (i->is_java_callable ())
417 "KnowledgeRecordFilters::filter: " 418 "Calling Java filter\n");
426 jclass jvarClass = madara::utility::java::find_class (
427 jvm.env,
"ai/madara/knowledge/Variables");
428 jclass jlistClass = madara::utility::java::find_class (
429 jvm.env,
"ai/madara/knowledge/KnowledgeList");
431 jmethodID fromPointerCall = jvm.env->GetStaticMethodID (jvarClass,
432 "fromPointer",
"(J)Lai/madara/knowledge/Variables;");
433 jobject jvariables = jvm.env->CallStaticObjectMethod (jvarClass,
434 fromPointerCall, (jlong)heap_variables.get ());
437 jmethodID listConstructor = jvm.env->GetMethodID (jlistClass,
440 jlongArray ret = jvm.env->NewLongArray ((jsize)arguments.size ());
441 jlong * tmp =
new jlong[(jsize)arguments.size ()];
443 for (
unsigned int x = 0; x < arguments.size (); x++)
445 tmp[x] = (jlong)arguments[x].clone ();
448 jvm.env->SetLongArrayRegion (ret, 0, (jsize)arguments.size (), tmp);
452 jobject jlist = jvm.env->NewObject (jlistClass, listConstructor, ret);
455 jclass filterClass = jvm.env->GetObjectClass (i->java_object);
458 jmethodID filterMethod = jvm.env->GetMethodID (filterClass,
460 "(Lai/madara/knowledge/KnowledgeList;" 461 "Lai/madara/knowledge/Variables;)Lai/madara/knowledge/KnowledgeRecord;");
466 "KnowledgeRecordFilters::filter: " 467 "Calling Java method\n");
470 jobject jresult = jvm.env->CallObjectMethod (i->java_object,
471 filterMethod, jlist, jvariables);
476 "KnowledgeRecordFilters::filter: " 477 "Obtaining pointer from Knowledge Record result\n");
479 jmethodID getPtrMethod = jvm.env->GetMethodID (
480 jvm.env->GetObjectClass (jresult),
"getCPtr",
"()J");
481 jlong cptr = jvm.env->CallLongMethod (jresult, getPtrMethod);
486 "KnowledgeRecordFilters::filter: " 487 "Checking return for origination outside of filter\n");
489 bool do_delete =
true;
491 for (
unsigned int x = 0; x < arguments.size (); x++)
493 if (cptr == (jlong)&(arguments[x]))
505 "KnowledgeRecordFilters::filter: " 506 "Doing a deep copy of the return value\n");
516 "KnowledgeRecordFilters::filter: " 517 "Deleting the original pointer\n");
522 jvm.env->DeleteWeakGlobalRef (jvarClass);
523 jvm.env->DeleteLocalRef (jvariables);
524 jvm.env->DeleteLocalRef (jresult);
525 jvm.env->DeleteLocalRef (jlist);
526 jvm.env->DeleteWeakGlobalRef (jlistClass);
527 jvm.env->DeleteLocalRef (ret);
531 #ifdef _MADARA_PYTHON_CALLBACKS_ 533 else if (i->is_python_callable ())
538 "KnowledgeRecordFilters::filter: " 539 "Calling Python filter\n");
545 result = boost::python::call <madara::knowledge::KnowledgeRecord> (
546 i->python_function.ptr (), boost::ref (arguments),
547 boost::ref (*heap_variables.get ()));
553 else if (i->is_extern_unnamed ())
558 "KnowledgeRecordFilters::filter: " 559 "Calling unnamed C filter\n");
561 result = i->extern_unnamed (arguments, *heap_variables.get ());
568 j + 1 < arguments.size (); j += 2)
570 if (arguments[j].is_string_type ())
575 "KnowledgeRecordFilters::filter: Adding %s " 576 "to transport context.\n", arguments[j].to_string ().c_str ());
579 arguments[j].to_string (), arguments[j + 1]);
586 "KnowledgeRecordFilters::filter: ERROR. Filter attempted to" 587 " add records to transport context, but args[%d] was not" 588 " a string value.\n", j);
611 "KnowledgeRecordFilters::filter: " 612 "Entering aggregate filter method\n");
615 std::unique_ptr <Variables> heap_variables (
618 heap_variables->context_ =
context_;
624 if (i->is_functor ())
629 "KnowledgeRecordFilters::filter: " 630 "Checking vars for null\n");
638 "KnowledgeRecordFilters::filter: " 639 "Calling C++ filter\n");
641 i->functor->filter (records, transport_context,
647 "KnowledgeRecordFilters::filter: " 648 "Finished calling C++ filter\n");
655 "KnowledgeRecordFilters::filter: " 656 "Memory issues caused vars to be null before filtering\n");
660 else if (i->is_java_callable ())
666 std::unique_ptr <KnowledgeMap> heap_records (
new KnowledgeMap (records));
667 std::unique_ptr <transport::TransportContext> heap_context (
673 jclass jvarClass = madara::utility::java::find_class (jvm.
env,
674 "ai/madara/knowledge/Variables");
675 jclass jpacketClass = madara::utility::java::find_class (jvm.
env,
676 "ai/madara/transport/filters/Packet");
677 jclass jcontextClass = madara::utility::java::find_class (jvm.
env,
678 "ai/madara/transport/TransportContext");
680 jmethodID varfromPointerCall = jvm.
env->GetStaticMethodID (
682 "fromPointer",
"(J)Lai/madara/knowledge/Variables;");
683 jobject jvariables = jvm.
env->CallStaticObjectMethod (
685 varfromPointerCall, (jlong)heap_variables.get ());
687 jmethodID packetfromPointerCall = jvm.
env->GetStaticMethodID (
689 "fromPointer",
"(J)Lai/madara/transport/filters/Packet;");
690 jobject jpacket = jvm.
env->CallStaticObjectMethod (jpacketClass,
691 packetfromPointerCall, (jlong)heap_records.get ());
693 jmethodID contextfromPointerCall = jvm.
env->GetStaticMethodID (
695 "fromPointer",
"(J)Lai/madara/transport/TransportContext;");
696 jobject jcontext = jvm.
env->CallStaticObjectMethod (jcontextClass,
697 contextfromPointerCall, (jlong)heap_context.get ());
700 jclass filterClass = jvm.
env->GetObjectClass (i->java_object);
701 jmethodID filterMethod = jvm.
env->GetMethodID (filterClass,
703 "(Lai/madara/transport/filters/Packet;" 704 "Lai/madara/transport/TransportContext;Lai/madara/knowledge/Variables;)V");
710 "KnowledgeRecordFilters::filter: " 711 "Calling Java method\n");
713 jvm.
env->CallVoidMethod (i->java_object, filterMethod,
714 jpacket, jcontext, jvariables);
719 "KnowledgeRecordFilters::filter: " 720 "Overwriting resulting records from heap records\n");
725 for (KnowledgeMap::const_iterator i = heap_records->begin ();
726 i != heap_records->end (); ++i)
728 records[i->first] = i->second;
731 jvm.
env->DeleteLocalRef (filterClass);
732 jvm.
env->DeleteLocalRef (jcontext);
733 jvm.
env->DeleteLocalRef (jpacket);
734 jvm.
env->DeleteWeakGlobalRef (jvarClass);
735 jvm.
env->DeleteWeakGlobalRef (jpacketClass);
736 jvm.
env->DeleteWeakGlobalRef (jcontextClass);
741 #ifdef _MADARA_PYTHON_CALLBACKS_ 743 else if (i->is_python_callable ())
749 boost::python::call <madara::knowledge::KnowledgeRecord> (
750 i->python_function.ptr (),
751 boost::ref (records), boost::ref (transport_context),
752 boost::ref (*heap_variables.get ()));
758 else if (i->is_extern_unnamed ())
760 i->unnamed_filter (records, transport_context,
761 *heap_variables.get ());
769 unsigned char * source,
int size,
int max_size)
const 772 for (filters::BufferFilters::const_reverse_iterator i =
buffer_filters_.rbegin ();
775 (*i)->decode (source, size, max_size);
780 unsigned char * source,
int size,
int max_size)
const 783 for (filters::BufferFilters::const_iterator i =
buffer_filters_.begin ();
786 (*i)->encode (source, size, max_size);
This class encapsulates an entry in a KnowledgeBase.
JNIEnv * env
The Java environment.
knowledge::KnowledgeRecord filter(const knowledge::KnowledgeRecord &input, const std::string &name, transport::TransportContext &context) const
Filters an input according to its filter chain.
This class encapsulates attaching and detaching to a VM.
void clear(uint32_t types)
Clears the list of filters for the specified types.
int32_t type(void) const
returns the size of the value
bool bitmask_check(T mask, T values)
Returns true if mask contains values.
helper type for specifying template type parameters using a function argument instead of inside expli...
This class stores a function definition.
void clear_aggregate_filters(void)
Clears the aggregate filters.
void filter_encode(unsigned char *source, int size, int max_size) const
Calls encode on the the buffer filter chain.
void filter_decode(unsigned char *source, int size, int max_size) const
Calls decode on the the buffer filter chain.
void print_num_filters(void) const
Prints the number of filters chained for each type.
Abstract base class for implementing aggregate record filters via a functor interface.
filters::BufferFilters buffer_filters_
List of buffer filters.
ThreadSafeContext * context_
Context used by this filter.
void attach(ThreadSafeContext *context)
Attaches a context.
This class stores variables and their values for use by any entity needing state information in a thr...
MADARA_EXPORT utility::Refcounter< logger::Logger > global_logger
Abstract base class for implementing individual record filters via a functor interface.
Provides map of data types to a filter chain to apply to the data.
std::vector< KnowledgeRecord > FunctionArguments
Provides context about the transport.
This class stores a function definition.
uint64_t get_receive_bandwidth(void) const
Gets the receive bandwidth in bytes per second.
#define madara_logger_cond_log(conditional, logger, alt_logger_ptr, level,...)
High-performance logger that performs conditional logging based on first arg.
KnowledgeRecordFilters()
Default constructor.
size_t get_number_of_buffer_filters(void) const
Returns the number of buffer filters.
uint64_t get_current_time(void) const
Gets the current timestamp.
void clear_buffer_filters(void)
Clears the buffer filters.
int64_t get_operation(void) const
Get operation that the context is performing.
AggregateFilters aggregate_filters_
List of aggregate filters.
::std::map< std::string, KnowledgeRecord > KnowledgeMap
virtual ~KnowledgeRecordFilters()
Destructor.
void add_record(const std::string &key, const madara::knowledge::KnowledgeRecord &record)
Adds a record to the list that should be appended to send or rebroadcast.
size_t get_number_of_filtered_types(void) const
Returns the number of types that have filters.
uint64_t get_message_time(void) const
Gets the message timestamp.
size_t get_number_of_aggregate_filters(void) const
Returns the number of aggregate update filters.
T bitmask_remove(T mask, T values)
Removes values from a bit mask.
void operator=(const KnowledgeRecordFilters &rhs)
Assignment operator.
This class encapsulates accessing the global interpreter lock.
const std::string & get_domain(void) const
Returns the network domain.
const std::string & get_originator(void) const
Returns the current message originator.
logger::Logger & get_logger(void) const
Gets the logger used for information printing.
Abstract base class for implementing buffer filters via a functor interface.
void add(uint32_t types, knowledge::KnowledgeRecord(*function)(FunctionArguments &, Variables &))
Adds a filter to the list of types.
knowledge::KnowledgeRecord get(const std::string &key, const KnowledgeReferenceSettings &settings=knowledge::KnowledgeReferenceSettings(false))
Retrieves the value of a variable.
Provides an interface for external functions into the MADARA KaRL variable settings.
std::list< Function > FilterChain
a chain of filters
FilterMap filters_
Container for mapping types to filter chains.
uint64_t get_send_bandwidth(void) const
Gets the send/rebroadcast bandwidth in bytes per second.