MADARA  3.1.8
JavaThread.cpp
Go to the documentation of this file.
1 #include "JavaThread.h"
2 
4 
6 
7 namespace threads = madara::threads;
8 namespace knowledge = madara::knowledge;
9 
11  : obj_ (0), class_ (0),
12  run_method_ (0), init_method_ (0), cleanup_method_ (0)
13 {
14 }
15 
17 {
18  // manage VM attachment
20 
21  if (jvm.env != 0)
22  {
24  "threads::JavaThread::destructor:"
25  " Deleting global references.\n");
26 
27  jvm.env->DeleteGlobalRef (obj_);
28  jvm.env->DeleteGlobalRef (class_);
29  }
30 }
31 
32 void
34 {
36  "threads::JavaThread::assignment:" \
37  " Checking for source not being same as dest\n");
38 
39  if (this != &rhs && obj_ != rhs.obj_)
40  {
41  JNIEnv * env = ::madara_jni_get_env ();
42 
43  // perform the assignment
44  if (env)
45  {
47  "threads::JavaThread::assignment:" \
48  " Deleting global references from left hand side\n");
49 
50  env->DeleteGlobalRef (obj_);
51  env->DeleteGlobalRef (class_);
52 
53  obj_ = env->NewGlobalRef (rhs.obj_);
54  class_ = (jclass) env->NewGlobalRef (rhs.class_);
58  }
59  }
60 }
61 
62 void
64 {
66  JNIEnv * env = jvm.env;
67 
69  "threads::JavaThread(%s)::run:" \
70  " Calling user-defined run method\n", name.c_str ());
71 
72  env->CallVoidMethod (obj_, run_method_);
73 }
74 
75 void
77 {
79  JNIEnv * env = jvm.env;
80 
82  "threads::JavaThread(%s)::cleanup:" \
83  " Calling user-defined cleanup method\n", name.c_str ());
84 
85  env->CallVoidMethod (obj_, cleanup_method_);
86 }
87 
88 void
90 {
92  JNIEnv * env = jvm.env;
93 
95  "threads::JavaThread(%s)::init:" \
96  " Creating Java KnowledgeBase from data plane\n", name.c_str ());
97 
98  jclass kb_class = madara::utility::java::find_class (env,
99  "com/madara/KnowledgeBase");
100 
101  jmethodID fromPointerCall = env->GetStaticMethodID (kb_class,
102  "fromPointer", "(JZ)Lcom/madara/KnowledgeBase;");
103 
104  jboolean manage (false);
105 
106  jobject jknowledge = env->CallStaticObjectMethod (kb_class,
107  fromPointerCall, (jlong) &context, manage);
108 
110  "threads::JavaThread(%s)::init:" \
111  " Calling user-defined init method\n", name.c_str ());
112 
113  env->CallVoidMethod (obj_, init_method_, jknowledge);
114 
115  env->DeleteLocalRef (jknowledge);
116  env->DeleteWeakGlobalRef (kb_class);
117 }
118 
119 
122 {
123  JavaThread * result = new JavaThread ();
124 
125  if (!result->check_compliance (obj))
126  {
127  delete result;
128  result = 0;
129  }
130 
131  return result;
132 }
133 
134 bool
136 {
138  JNIEnv * env = jvm.env;
139 
140  bool result (true);
141 
142  if (env)
143  {
145  "threads::JavaThread(%s)::check_compliance:" \
146  " allocating global reference for object\n", name.c_str ());
147 
148  obj_ = (jobject) env->NewGlobalRef (obj);
149 
150  if (obj_)
151  {
153  "threads::JavaThread(%s)::check_compliance:" \
154  " allocating global reference for object's class\n", name.c_str ());
155 
156  class_ = (jclass) env->NewGlobalRef (env->GetObjectClass (obj_));
157  if (class_)
158  {
160  "threads::JavaThread(%s)::check_compliance:" \
161  " class and object obtained successfully\n", name.c_str ());
162 
163  // stash the method calls to minimize call time
164  run_method_ = env->GetMethodID(class_,
165  "run", "()V" );
166  init_method_ = env->GetMethodID(class_,
167  "init", "(Lcom/madara/KnowledgeBase;)V" );
168  cleanup_method_ = env->GetMethodID(class_,
169  "cleanup", "()V" );
170 
171  if (!run_method_)
172  {
174  "threads::JavaThread(%s)::check_compliance:" \
175  " ERROR: run method must be defined\n", name.c_str ());
176 
177  result = false;
178  }
179 
180  if (!init_method_)
181  {
183  "threads::JavaThread(%s)::check_compliance:" \
184  " ERROR: init method must be defined\n", name.c_str ());
185 
186  result = false;
187  }
188 
189  if (!cleanup_method_)
190  {
192  "threads::JavaThread(%s)::check_compliance:" \
193  " ERROR: cleanup method must be defined\n", name.c_str ());
194 
195  result = false;
196  }
197  }
198  else
199  {
201  "threads::JavaThread(%s)::check_compliance:" \
202  " ERROR: class object inaccessible\n", name.c_str ());
203 
204  result = false;
205  }
206  }
207  else
208  {
210  "threads::JavaThread(%s)::check_compliance:" \
211  " ERROR: object is invalid\n", name.c_str ());
212 
213  result = false;
214  }
215  }
216  else
217  {
219  "threads::JavaThread(%s)::check_compliance:" \
220  " ERROR: unable to acquire JAVA environment\n", name.c_str ());
221 
222  result = false;
223  }
224 
225  return result;
226 }
227 
228 void
230 {
231  // Initialize the underlying control variables
233 
234  // setup the Java variables
236  JNIEnv * env = ::madara_jni_get_env ();
237 
239  "threads::JavaThread(%s)::init_control_vars:" \
240  " Populating user control plane variables\n", name.c_str ());
241 
242  // obtain fromPointer method for com.madara.containers.Integer
243  jclass i_class = madara::utility::java::find_class (env,
244  "com/madara/containers/Integer");
245  jmethodID fromPointerCall = env->GetStaticMethodID (i_class,
246  "fromPointer", "(JZ)Lcom/madara/containers/Integer;");
247 
248  // the user thread should not manage C++ memory. We'll do that.
249  jboolean manage (false);
250 
251  // create java objects for the underlying containers
252  jobject jterminate = env->CallStaticObjectMethod (i_class,
253  fromPointerCall, (jlong) &terminated, manage);
254  jobject jpaused = env->CallStaticObjectMethod (i_class,
255  fromPointerCall, (jlong) &paused, manage);
256 
257  // set the user-defined threads's containers to these new containers
258  jfieldID fieldId = env->GetFieldID(class_,
259  "terminated","Lcom/madara/containers/Integer;");
260  env->SetObjectField (obj_, fieldId, jterminate);
261 
262  fieldId = env->GetFieldID(class_,
263  "paused","Lcom/madara/containers/Integer;");
264  env->SetObjectField (obj_, fieldId, jpaused);
265 
266  jvm.env->DeleteWeakGlobalRef (i_class);
267  jvm.env->DeleteLocalRef (jterminate);
268  jvm.env->DeleteLocalRef (jpaused);
269 }
JNIEnv * env
The Java environment.
Definition: Acquire_VM.h:58
madara::knowledge::containers::Integer paused
thread safe paused flag that may be set by the Threader
Definition: BaseThread.h:107
jmethodID run_method_
handle to the run method
Definition: JavaThread.h:91
This class encapsulates attaching and detaching to a VM.
Definition: Acquire_VM.h:24
bool check_compliance(jobject obj)
Checks a Java object for compliance with com.madara.threads.BaseThread.
Definition: JavaThread.cpp:135
virtual void init_control_vars(knowledge::KnowledgeBase &control)
Initializes the Java thread implementation's control plane variables.
Definition: BaseThread.h:86
madara::knowledge::containers::Integer terminated
thread safe terminated flag that may be set by the Threader base
Definition: BaseThread.h:102
MADARA_Export utility::Refcounter< logger::Logger > global_logger
jclass class_
the class of the Java object obj_
Definition: JavaThread.h:88
virtual void run(void)
Executes the Java thread&#39;s logic.
Definition: JavaThread.cpp:63
Provides a quality-of-service-enabled threading library.
Definition: BaseThread.h:27
virtual void init_control_vars(knowledge::KnowledgeBase &control)
Initializes the Java thread implementation&#39;s control plane variables.
Definition: JavaThread.cpp:229
#define madara_logger_ptr_log(logger, level,...)
Fast version of the madara::logger::log method for Logger pointers.
Definition: Logger.h:32
virtual void cleanup(void)
Calls the Java cleanup method.
Definition: JavaThread.cpp:76
This class provides a distributed knowledge base to users.
Definition: KnowledgeBase.h:44
void operator=(const JavaThread &rhs)
Assignment operator.
Definition: JavaThread.cpp:33
virtual void init(knowledge::KnowledgeBase &context)
Initializes Java thread with MADARA context.
Definition: JavaThread.cpp:89
jmethodID cleanup_method_
handle to the cleanup method
Definition: JavaThread.h:97
std::string name
The unique name of your thread.
Definition: BaseThread.h:96
Provides functions and classes for the distributed knowledge base.
jmethodID init_method_
handle to the init method
Definition: JavaThread.h:94
jobject obj_
the Java thread implementation of com.madara.threads.BaseThread
Definition: JavaThread.h:85
A facade for a user-defined Java thread class.
Definition: JavaThread.h:26
static JavaThread * create(jobject obj)
Creates a JavaThread.
Definition: JavaThread.cpp:121