You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@reef.apache.org by we...@apache.org on 2015/01/29 18:06:50 UTC

[2/2] incubator-reef git commit: [REEF-96] Update C# namespace referenced in Reef bridge project

[REEF-96] Update C# namespace referenced in Reef bridge project

We have prepared to move .Net Reef code to Apache Git. We also updated
namespaces for .Net code. In Reef bridge code, driver.dll is used whose name
space need to be updated to Org.Apache.Reef.Driver.

In Tang serialization testing for cross languages, we also referenced .Net name
space. It needs to be updated as well. Class hierarchy files used in test also
need to be updated.

This is to:
	* Update name space in bridge project
	* Update driver file
	* Updated name space used in Tang test and examples
	* Update class hierarchy files in testing

JIRA: [REEF-96] https://issues.apache.org/jira/browse/REEF-96

Pull Request: This closes #57


Project: http://git-wip-us.apache.org/repos/asf/incubator-reef/repo
Commit: http://git-wip-us.apache.org/repos/asf/incubator-reef/commit/5cc60715
Tree: http://git-wip-us.apache.org/repos/asf/incubator-reef/tree/5cc60715
Diff: http://git-wip-us.apache.org/repos/asf/incubator-reef/diff/5cc60715

Branch: refs/heads/master
Commit: 5cc6071589ccedc46c83627d4ae9210e62e6af7b
Parents: e7c407e
Author: Julia Wang <ju...@microsoft.com>
Authored: Fri Jan 23 16:03:46 2015 -0800
Committer: Markus Weimer <we...@apache.org>
Committed: Thu Jan 29 09:02:25 2015 -0800

----------------------------------------------------------------------
 .../CSharp/CSharp/ClrHandler/ClrHandler.csproj  |   4 +-
 .../externals/Microsoft.Reef.Driver.dll         | Bin 123392 -> 0 bytes
 .../externals/Org.Apache.Reef.Driver.dll        | Bin 0 -> 121344 bytes
 .../JavaClrBridge/ActiveContextClr2Java.cpp     | 144 +++----
 .../AllocatedEvaluatorClr2Java.cpp              | 282 +++++++-------
 .../JavaClrBridge/ClosedContextClr2Java.cpp     | 106 +++---
 .../Cpp/CppBridge/JavaClrBridge/Clr2JavaImpl.h  | 380 ++++++++++---------
 .../CppBridge/JavaClrBridge/CommonUtilities.cpp |  54 +--
 .../CompletedEvaluatorClr2Java.cpp              |  66 ++--
 .../JavaClrBridge/CompletedTaskClr2Java.cpp     |  84 ++--
 .../JavaClrBridge/ContextMessageClr2Java.cpp    |  94 ++---
 .../EvaluatorRequestorClr2Java.cpp              |  88 ++---
 .../JavaClrBridge/FailedContextClr2Java.cpp     | 120 +++---
 .../JavaClrBridge/FailedEvaluatorClr2Java.cpp   |  84 ++--
 .../JavaClrBridge/FailedTaskClr2Java.cpp        |  98 ++---
 .../JavaClrBridge/HttpServerClr2Java.cpp        | 202 +++++-----
 .../JavaClrBridge/InteropReturnInfo.cpp         |   3 -
 .../CppBridge/JavaClrBridge/JavaClrBridge.cpp   |   2 +-
 .../JavaClrBridge/RunningTaskClr2Java.cpp       | 114 +++---
 .../JavaClrBridge/SuspendedTaskClr2Java.cpp     | 108 +++---
 .../JavaClrBridge/TaskMessageClr2Java.cpp       |  66 ++--
 .../common/launch/CLRLaunchCommandBuilder.java  |   2 +-
 .../reef/examples/helloCLR/HelloDriver.java     |   4 +-
 .../examples/retained_evalCLR/JobDriver.java    |   6 +-
 .../tang/ClassHierarchyDeserializationTest.java |  14 +-
 .../reef-tang/tang/src/test/resources/Event.bin | Bin 24188 -> 26176 bytes
 .../reef-tang/tang/src/test/resources/Task.bin  | Bin 128600 -> 131328 bytes
 27 files changed, 1080 insertions(+), 1045 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/ClrHandler.csproj
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/ClrHandler.csproj b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/ClrHandler.csproj
index 952dd0d..c3207c5 100644
--- a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/ClrHandler.csproj
+++ b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/ClrHandler.csproj
@@ -37,8 +37,8 @@
     </AssemblyOriginatorKeyFile>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="Microsoft.Reef.Driver">
-      <HintPath>externals\Microsoft.Reef.Driver.dll</HintPath>
+    <Reference Include="Org.Apache.Reef.Driver">
+      <HintPath>externals\Org.Apache.Reef.Driver</HintPath>
       <Private>true</Private>
     </Reference>
     <Reference Include="System" />

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/externals/Microsoft.Reef.Driver.dll
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/externals/Microsoft.Reef.Driver.dll b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/externals/Microsoft.Reef.Driver.dll
deleted file mode 100644
index d95a8c7..0000000
Binary files a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/externals/Microsoft.Reef.Driver.dll and /dev/null differ

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/externals/Org.Apache.Reef.Driver.dll
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/externals/Org.Apache.Reef.Driver.dll b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/externals/Org.Apache.Reef.Driver.dll
new file mode 100644
index 0000000..63582c0
Binary files /dev/null and b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/CSharp/CSharp/ClrHandler/externals/Org.Apache.Reef.Driver.dll differ

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ActiveContextClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ActiveContextClr2Java.cpp b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ActiveContextClr2Java.cpp
index fc04b06..c381f50 100644
--- a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ActiveContextClr2Java.cpp
+++ b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ActiveContextClr2Java.cpp
@@ -18,89 +18,91 @@
  */
 #include "Clr2JavaImpl.h"
 
-namespace Microsoft {
-  namespace Reef {
-    namespace Driver {
-      namespace Bridge {
-        private ref class ManagedLog {
-          internal:
-            static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
-        };
+namespace Org {
+	namespace Apache {
+		namespace Reef {
+			namespace Driver {
+				namespace Bridge {
+					private ref class ManagedLog {
+						internal:
+							static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+					};
 
-        ActiveContextClr2Java::ActiveContextClr2Java(JNIEnv *env, jobject jobjectActiveContext) {
-          ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::ActiveContextClr2Java");
-          pin_ptr<JavaVM*> pJavaVm = &_jvm;
-          if (env->GetJavaVM(pJavaVm) != 0) {
-            ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
-          }
+					ActiveContextClr2Java::ActiveContextClr2Java(JNIEnv *env, jobject jobjectActiveContext) {
+						ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::ActiveContextClr2Java");
+						pin_ptr<JavaVM*> pJavaVm = &_jvm;
+						if (env->GetJavaVM(pJavaVm) != 0) {
+							ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+						}
 
-          _jobjectActiveContext = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectActiveContext));
+						_jobjectActiveContext = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectActiveContext));
 
-          jclass jclassActiveContext = env->GetObjectClass(_jobjectActiveContext);
+						jclass jclassActiveContext = env->GetObjectClass(_jobjectActiveContext);
 
-          jfieldID jidContextId = env->GetFieldID(jclassActiveContext, "contextId", "Ljava/lang/String;");
-          _jstringId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectActiveContext, jidContextId)));
+						jfieldID jidContextId = env->GetFieldID(jclassActiveContext, "contextId", "Ljava/lang/String;");
+						_jstringId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectActiveContext, jidContextId)));
 
-          jfieldID jidEvaluatorId = env->GetFieldID(jclassActiveContext, "evaluatorId", "Ljava/lang/String;");
-          _jstringEvaluatorId = (jstring)env->GetObjectField(_jobjectActiveContext, jidEvaluatorId);
-          _jstringEvaluatorId = reinterpret_cast<jstring>(env->NewGlobalRef(_jstringEvaluatorId));
+						jfieldID jidEvaluatorId = env->GetFieldID(jclassActiveContext, "evaluatorId", "Ljava/lang/String;");
+						_jstringEvaluatorId = (jstring)env->GetObjectField(_jobjectActiveContext, jidEvaluatorId);
+						_jstringEvaluatorId = reinterpret_cast<jstring>(env->NewGlobalRef(_jstringEvaluatorId));
 
-          ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::ActiveContextClr2Java");
-        }
+						ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::ActiveContextClr2Java");
+					}
 
-        void ActiveContextClr2Java::SubmitTask(String^ taskConfigStr) {
-          ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::SubmitTask");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          jclass jclassActiveContext = env->GetObjectClass (_jobjectActiveContext);
-          jmethodID jmidSubmitTask = env->GetMethodID(jclassActiveContext, "submitTaskString", "(Ljava/lang/String;)V");
+					void ActiveContextClr2Java::SubmitTask(String^ taskConfigStr) {
+						ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::SubmitTask");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						jclass jclassActiveContext = env->GetObjectClass (_jobjectActiveContext);
+						jmethodID jmidSubmitTask = env->GetMethodID(jclassActiveContext, "submitTaskString", "(Ljava/lang/String;)V");
 
-          if (jmidSubmitTask == NULL) {
-            ManagedLog::LOGGER->Log("jmidSubmitTask is NULL");
-            return;
-          }
-          env -> CallObjectMethod(
-            _jobjectActiveContext,
-            jmidSubmitTask,
-            JavaStringFromManagedString(env, taskConfigStr));
-          ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::SubmitTask");
-        }
+						if (jmidSubmitTask == NULL) {
+							ManagedLog::LOGGER->Log("jmidSubmitTask is NULL");
+							return;
+						}
+						env -> CallObjectMethod(
+							_jobjectActiveContext,
+							jmidSubmitTask,
+							JavaStringFromManagedString(env, taskConfigStr));
+						ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::SubmitTask");
+					}
 
-        void ActiveContextClr2Java::OnError(String^ message) {
-          JNIEnv *env = RetrieveEnv(_jvm);
-          HandleClr2JavaError(env, message, _jobjectActiveContext);
-        }
+					void ActiveContextClr2Java::OnError(String^ message) {
+						JNIEnv *env = RetrieveEnv(_jvm);
+						HandleClr2JavaError(env, message, _jobjectActiveContext);
+					}
 
-        void ActiveContextClr2Java::Close() {
-          ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::Close");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          jclass jclassActiveContext = env->GetObjectClass (_jobjectActiveContext);
-          jmethodID jmidClose = env->GetMethodID(jclassActiveContext, "close", "()V");
+					void ActiveContextClr2Java::Close() {
+						ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::Close");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						jclass jclassActiveContext = env->GetObjectClass (_jobjectActiveContext);
+						jmethodID jmidClose = env->GetMethodID(jclassActiveContext, "close", "()V");
 
-          if (jmidClose == NULL) {
-            ManagedLog::LOGGER->Log("jmidClose is NULL");
-            return;
-          }
-          env -> CallObjectMethod(
-            _jobjectActiveContext,
-            jmidClose);
-          ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::Close");
-        }
+						if (jmidClose == NULL) {
+							ManagedLog::LOGGER->Log("jmidClose is NULL");
+							return;
+						}
+						env -> CallObjectMethod(
+							_jobjectActiveContext,
+							jmidClose);
+						ManagedLog::LOGGER->LogStop("ActiveContextClr2Java::Close");
+					}
 
-        String^ ActiveContextClr2Java::GetId() {
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringId);
-        }
+					String^ ActiveContextClr2Java::GetId() {
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringId);
+					}
 
-        String^ ActiveContextClr2Java::GetEvaluatorId() {
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringEvaluatorId);
-        }
+					String^ ActiveContextClr2Java::GetEvaluatorId() {
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringEvaluatorId);
+					}
 
-        IEvaluatorDescriptor^ ActiveContextClr2Java::GetEvaluatorDescriptor() {
-          ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::GetEvaluatorDescriptor");
-          return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectActiveContext, _jvm);
-        }
-      }
-    }
-  }
+					IEvaluatorDescriptor^ ActiveContextClr2Java::GetEvaluatorDescriptor() {
+						ManagedLog::LOGGER->LogStart("ActiveContextClr2Java::GetEvaluatorDescriptor");
+						return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectActiveContext, _jvm);
+					}
+				}
+			}
+		}
+	}
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/AllocatedEvaluatorClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/AllocatedEvaluatorClr2Java.cpp b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/AllocatedEvaluatorClr2Java.cpp
index 11e8a80..6f158bc 100644
--- a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/AllocatedEvaluatorClr2Java.cpp
+++ b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/AllocatedEvaluatorClr2Java.cpp
@@ -20,145 +20,147 @@
 
 using namespace JavaClrBridge;
 
-namespace Microsoft {
-  namespace Reef {
-    namespace Driver {
-      namespace Bridge {
-        ref class ManagedLog {
-          internal:
-            static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
-        };
-
-        AllocatedEvaluatorClr2Java::AllocatedEvaluatorClr2Java(JNIEnv *env, jobject jallocatedEvaluator) {
-
-          ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::AllocatedEvaluatorClr2Java");
-
-          pin_ptr<JavaVM*> pJavaVm = &_jvm;
-          if (env->GetJavaVM(pJavaVm) != 0) {
-            ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
-          }
-          _jobjectAllocatedEvaluator = reinterpret_cast<jobject>(env->NewGlobalRef(jallocatedEvaluator));
-
-          jclass jclassAllocatedEvaluator = env->GetObjectClass (_jobjectAllocatedEvaluator);
-          jfieldID jidEvaluatorId = env->GetFieldID(jclassAllocatedEvaluator, "evaluatorId", "Ljava/lang/String;");
-          _jstringId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectAllocatedEvaluator, jidEvaluatorId)));
-
-          jfieldID jidNameServerInfo = env->GetFieldID(jclassAllocatedEvaluator, "nameServerInfo", "Ljava/lang/String;");
-          _jstringNameServerInfo = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectAllocatedEvaluator, jidNameServerInfo)));
-
-          ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::AllocatedEvaluatorClr2Java");
-        }
-
-        void AllocatedEvaluatorClr2Java::SubmitContext(String^ contextConfigStr) {
-          ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContext");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          jclass jclassAllocatedEvaluator = env->GetObjectClass (_jobjectAllocatedEvaluator);
-          jmethodID jmidSubmitContext = env->GetMethodID(jclassAllocatedEvaluator, "submitContextString", "(Ljava/lang/String;)V");
-
-          if (jmidSubmitContext == NULL) {
-            ManagedLog::LOGGER->Log("jmidSubmitContext is NULL");
-            return;
-          }
-          env -> CallObjectMethod(
-            _jobjectAllocatedEvaluator,
-            jmidSubmitContext,
-            JavaStringFromManagedString(env, contextConfigStr));
-          ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContext");
-        }
-
-        void AllocatedEvaluatorClr2Java::SubmitContextAndTask(String^ contextConfigStr, String^ taskConfigStr) {
-          ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContextAndTask");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          jclass jclassAllocatedEvaluator = env->GetObjectClass (_jobjectAllocatedEvaluator);
-          jmethodID jmidSubmitContextAndTask = env->GetMethodID(jclassAllocatedEvaluator, "submitContextAndTaskString", "(Ljava/lang/String;Ljava/lang/String;)V");
-
-          if (jmidSubmitContextAndTask == NULL) {
-            ManagedLog::LOGGER->Log("jmidSubmitContextAndTask is NULL");
-            return;
-          }
-          env -> CallObjectMethod(
-            _jobjectAllocatedEvaluator,
-            jmidSubmitContextAndTask,
-            JavaStringFromManagedString(env, contextConfigStr),
-            JavaStringFromManagedString(env, taskConfigStr));
-          ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContextAndTask");
-        }
-
-        void AllocatedEvaluatorClr2Java::SubmitContextAndService(String^ contextConfigStr, String^ serviceConfigStr) {
-          ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContextAndService");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          jclass jclassAllocatedEvaluator = env->GetObjectClass (_jobjectAllocatedEvaluator);
-          jmethodID jmidSubmitContextAndService = env->GetMethodID(jclassAllocatedEvaluator, "submitContextAndServiceString", "(Ljava/lang/String;Ljava/lang/String;)V");
-
-          if (jmidSubmitContextAndService == NULL) {
-            ManagedLog::LOGGER->Log("jmidSubmitContextAndService is NULL");
-            return;
-          }
-          env -> CallObjectMethod(
-            _jobjectAllocatedEvaluator,
-            jmidSubmitContextAndService,
-            JavaStringFromManagedString(env, contextConfigStr),
-            JavaStringFromManagedString(env, serviceConfigStr));
-          ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContextAndService");
-        }
-
-        void AllocatedEvaluatorClr2Java::SubmitContextAndServiceAndTask(String^ contextConfigStr, String^ serviceConfigStr, String^ taskConfigStr) {
-          ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContextAndServiceAndTask");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          jclass jclassAllocatedEvaluator = env->GetObjectClass (_jobjectAllocatedEvaluator);
-          jmethodID jmidSubmitContextAndServiceAndTask = env->GetMethodID(jclassAllocatedEvaluator, "submitContextAndServiceAndTaskString", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
-
-          if (jmidSubmitContextAndServiceAndTask == NULL) {
-            ManagedLog::LOGGER->Log("jmidSubmitContextAndServiceAndTask is NULL");
-            return;
-          }
-          env -> CallObjectMethod(
-            _jobjectAllocatedEvaluator,
-            jmidSubmitContextAndServiceAndTask,
-            JavaStringFromManagedString(env, contextConfigStr),
-            JavaStringFromManagedString(env, serviceConfigStr),
-            JavaStringFromManagedString(env, taskConfigStr));
-          ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContextAndServiceAndTask");
-        }
-
-        void AllocatedEvaluatorClr2Java::OnError(String^ message) {
-          JNIEnv *env = RetrieveEnv(_jvm);
-          HandleClr2JavaError(env, message, _jobjectAllocatedEvaluator);
-        }
-
-        void AllocatedEvaluatorClr2Java::Close() {
-          ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::Close");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          jclass jclassAllocatedEvaluator = env->GetObjectClass (_jobjectAllocatedEvaluator);
-          jmethodID jmidClose = env->GetMethodID(jclassAllocatedEvaluator, "close", "()V");
-
-          if (jmidClose == NULL) {
-            ManagedLog::LOGGER->Log("jmidClose is NULL");
-            return;
-          }
-          env -> CallObjectMethod(
-            _jobjectAllocatedEvaluator,
-            jmidClose);
-          ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::Close");
-        }
-
-        String^ AllocatedEvaluatorClr2Java::GetId() {
-          ManagedLog::LOGGER->Log("AllocatedEvaluatorClr2Java::GetId");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringId);
-        }
-
-        String^ AllocatedEvaluatorClr2Java::GetNameServerInfo() {
-          ManagedLog::LOGGER->Log("AllocatedEvaluatorClr2Java::GetNameServerInfo");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringNameServerInfo);
-        }
-
-        IEvaluatorDescriptor^ AllocatedEvaluatorClr2Java::GetEvaluatorDescriptor() {
-          ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::GetEvaluatorDescriptor");
-          return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectAllocatedEvaluator, _jvm);
-        }
-      }
-    }
+namespace Org {
+  namespace Apache {
+		namespace Reef {
+			namespace Driver {
+				namespace Bridge {
+					ref class ManagedLog {
+						internal:
+							static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+					};
+
+					AllocatedEvaluatorClr2Java::AllocatedEvaluatorClr2Java(JNIEnv *env, jobject jallocatedEvaluator) {
+
+						ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::AllocatedEvaluatorClr2Java");
+
+						pin_ptr<JavaVM*> pJavaVm = &_jvm;
+						if (env->GetJavaVM(pJavaVm) != 0) {
+							ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+						}
+						_jobjectAllocatedEvaluator = reinterpret_cast<jobject>(env->NewGlobalRef(jallocatedEvaluator));
+
+						jclass jclassAllocatedEvaluator = env->GetObjectClass (_jobjectAllocatedEvaluator);
+						jfieldID jidEvaluatorId = env->GetFieldID(jclassAllocatedEvaluator, "evaluatorId", "Ljava/lang/String;");
+						_jstringId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectAllocatedEvaluator, jidEvaluatorId)));
+
+						jfieldID jidNameServerInfo = env->GetFieldID(jclassAllocatedEvaluator, "nameServerInfo", "Ljava/lang/String;");
+						_jstringNameServerInfo = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectAllocatedEvaluator, jidNameServerInfo)));
+
+						ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::AllocatedEvaluatorClr2Java");
+					}
+
+					void AllocatedEvaluatorClr2Java::SubmitContext(String^ contextConfigStr) {
+						ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContext");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						jclass jclassAllocatedEvaluator = env->GetObjectClass (_jobjectAllocatedEvaluator);
+						jmethodID jmidSubmitContext = env->GetMethodID(jclassAllocatedEvaluator, "submitContextString", "(Ljava/lang/String;)V");
+
+						if (jmidSubmitContext == NULL) {
+							ManagedLog::LOGGER->Log("jmidSubmitContext is NULL");
+							return;
+						}
+						env -> CallObjectMethod(
+							_jobjectAllocatedEvaluator,
+							jmidSubmitContext,
+							JavaStringFromManagedString(env, contextConfigStr));
+						ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContext");
+					}
+
+					void AllocatedEvaluatorClr2Java::SubmitContextAndTask(String^ contextConfigStr, String^ taskConfigStr) {
+						ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContextAndTask");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						jclass jclassAllocatedEvaluator = env->GetObjectClass (_jobjectAllocatedEvaluator);
+						jmethodID jmidSubmitContextAndTask = env->GetMethodID(jclassAllocatedEvaluator, "submitContextAndTaskString", "(Ljava/lang/String;Ljava/lang/String;)V");
+
+						if (jmidSubmitContextAndTask == NULL) {
+							ManagedLog::LOGGER->Log("jmidSubmitContextAndTask is NULL");
+							return;
+						}
+						env -> CallObjectMethod(
+							_jobjectAllocatedEvaluator,
+							jmidSubmitContextAndTask,
+							JavaStringFromManagedString(env, contextConfigStr),
+							JavaStringFromManagedString(env, taskConfigStr));
+						ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContextAndTask");
+					}
+
+					void AllocatedEvaluatorClr2Java::SubmitContextAndService(String^ contextConfigStr, String^ serviceConfigStr) {
+						ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContextAndService");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						jclass jclassAllocatedEvaluator = env->GetObjectClass (_jobjectAllocatedEvaluator);
+						jmethodID jmidSubmitContextAndService = env->GetMethodID(jclassAllocatedEvaluator, "submitContextAndServiceString", "(Ljava/lang/String;Ljava/lang/String;)V");
+
+						if (jmidSubmitContextAndService == NULL) {
+							ManagedLog::LOGGER->Log("jmidSubmitContextAndService is NULL");
+							return;
+						}
+						env -> CallObjectMethod(
+							_jobjectAllocatedEvaluator,
+							jmidSubmitContextAndService,
+							JavaStringFromManagedString(env, contextConfigStr),
+							JavaStringFromManagedString(env, serviceConfigStr));
+						ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContextAndService");
+					}
+
+					void AllocatedEvaluatorClr2Java::SubmitContextAndServiceAndTask(String^ contextConfigStr, String^ serviceConfigStr, String^ taskConfigStr) {
+						ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::SubmitContextAndServiceAndTask");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						jclass jclassAllocatedEvaluator = env->GetObjectClass (_jobjectAllocatedEvaluator);
+						jmethodID jmidSubmitContextAndServiceAndTask = env->GetMethodID(jclassAllocatedEvaluator, "submitContextAndServiceAndTaskString", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)V");
+
+						if (jmidSubmitContextAndServiceAndTask == NULL) {
+							ManagedLog::LOGGER->Log("jmidSubmitContextAndServiceAndTask is NULL");
+							return;
+						}
+						env -> CallObjectMethod(
+							_jobjectAllocatedEvaluator,
+							jmidSubmitContextAndServiceAndTask,
+							JavaStringFromManagedString(env, contextConfigStr),
+							JavaStringFromManagedString(env, serviceConfigStr),
+							JavaStringFromManagedString(env, taskConfigStr));
+						ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::SubmitContextAndServiceAndTask");
+					}
+
+					void AllocatedEvaluatorClr2Java::OnError(String^ message) {
+						JNIEnv *env = RetrieveEnv(_jvm);
+						HandleClr2JavaError(env, message, _jobjectAllocatedEvaluator);
+					}
+
+					void AllocatedEvaluatorClr2Java::Close() {
+						ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::Close");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						jclass jclassAllocatedEvaluator = env->GetObjectClass (_jobjectAllocatedEvaluator);
+						jmethodID jmidClose = env->GetMethodID(jclassAllocatedEvaluator, "close", "()V");
+
+						if (jmidClose == NULL) {
+							ManagedLog::LOGGER->Log("jmidClose is NULL");
+							return;
+						}
+						env -> CallObjectMethod(
+							_jobjectAllocatedEvaluator,
+							jmidClose);
+						ManagedLog::LOGGER->LogStop("AllocatedEvaluatorClr2Java::Close");
+					}
+
+					String^ AllocatedEvaluatorClr2Java::GetId() {
+						ManagedLog::LOGGER->Log("AllocatedEvaluatorClr2Java::GetId");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringId);
+					}
+
+					String^ AllocatedEvaluatorClr2Java::GetNameServerInfo() {
+						ManagedLog::LOGGER->Log("AllocatedEvaluatorClr2Java::GetNameServerInfo");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringNameServerInfo);
+					}
+
+					IEvaluatorDescriptor^ AllocatedEvaluatorClr2Java::GetEvaluatorDescriptor() {
+						ManagedLog::LOGGER->LogStart("AllocatedEvaluatorClr2Java::GetEvaluatorDescriptor");
+						return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectAllocatedEvaluator, _jvm);
+					}
+				}
+			}
+		}
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ClosedContextClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ClosedContextClr2Java.cpp b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ClosedContextClr2Java.cpp
index d87d17a..a141f45 100644
--- a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ClosedContextClr2Java.cpp
+++ b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ClosedContextClr2Java.cpp
@@ -18,69 +18,71 @@
  */
 #include "Clr2JavaImpl.h"
 
-namespace Microsoft {
-  namespace Reef {
-    namespace Driver {
-      namespace Bridge {
-        ref class ManagedLog {
-          internal:
-            static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
-        };
-        ClosedContextClr2Java::ClosedContextClr2Java(JNIEnv *env, jobject jobjectClosedContext) {
-          ManagedLog::LOGGER->LogStart("ClosedContextClr2Java::ClosedContextClr2Java");
+namespace Org {
+  namespace Apache {
+		namespace Reef {
+			namespace Driver {
+				namespace Bridge {
+					ref class ManagedLog {
+						internal:
+							static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+					};
+					ClosedContextClr2Java::ClosedContextClr2Java(JNIEnv *env, jobject jobjectClosedContext) {
+						ManagedLog::LOGGER->LogStart("ClosedContextClr2Java::ClosedContextClr2Java");
 
-          pin_ptr<JavaVM*> pJavaVm = &_jvm;
-          if (env->GetJavaVM(pJavaVm) != 0) {
-            ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
-          }
-          _jobjectClosedContext = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectClosedContext));
-          jclass jclassClosedContext = env->GetObjectClass (_jobjectClosedContext);
+						pin_ptr<JavaVM*> pJavaVm = &_jvm;
+						if (env->GetJavaVM(pJavaVm) != 0) {
+							ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+						}
+						_jobjectClosedContext = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectClosedContext));
+						jclass jclassClosedContext = env->GetObjectClass (_jobjectClosedContext);
 
-          jfieldID jidContextId = env->GetFieldID(jclassClosedContext, "contextId", "Ljava/lang/String;");
-          jfieldID jidEvaluatorId = env->GetFieldID(jclassClosedContext, "evaluatorId", "Ljava/lang/String;");
+						jfieldID jidContextId = env->GetFieldID(jclassClosedContext, "contextId", "Ljava/lang/String;");
+						jfieldID jidEvaluatorId = env->GetFieldID(jclassClosedContext, "evaluatorId", "Ljava/lang/String;");
 
-          _jstringContextId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectClosedContext, jidContextId)));
-          _jstringEvaluatorId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectClosedContext, jidEvaluatorId)));
+						_jstringContextId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectClosedContext, jidContextId)));
+						_jstringEvaluatorId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectClosedContext, jidEvaluatorId)));
 
-          ManagedLog::LOGGER->LogStop("ClosedContextClr2Java::ClosedContextClr2Java");
-        }
+						ManagedLog::LOGGER->LogStop("ClosedContextClr2Java::ClosedContextClr2Java");
+					}
 
-        IActiveContextClr2Java^ ClosedContextClr2Java::GetParentContext() {
-          ManagedLog::LOGGER->LogStart("ClosedContextClr2Java::GetParentContext");
+					IActiveContextClr2Java^ ClosedContextClr2Java::GetParentContext() {
+						ManagedLog::LOGGER->LogStart("ClosedContextClr2Java::GetParentContext");
 
-          JNIEnv *env = RetrieveEnv(_jvm);
+						JNIEnv *env = RetrieveEnv(_jvm);
 
-          jclass jclassClosedContext = env->GetObjectClass(_jobjectClosedContext);
-          jfieldID jidParentContext = env->GetFieldID(jclassClosedContext, "parentContext", "Lorg/apache/reef/javabridge/ActiveContextBridge;");
-          jobject jobjectParentContext = env->GetObjectField(_jobjectClosedContext, jidParentContext);
-          ManagedLog::LOGGER->LogStop("ClosedContextClr2Java::GetParentContext");
+						jclass jclassClosedContext = env->GetObjectClass(_jobjectClosedContext);
+						jfieldID jidParentContext = env->GetFieldID(jclassClosedContext, "parentContext", "Lorg/apache/reef/javabridge/ActiveContextBridge;");
+						jobject jobjectParentContext = env->GetObjectField(_jobjectClosedContext, jidParentContext);
+						ManagedLog::LOGGER->LogStop("ClosedContextClr2Java::GetParentContext");
 
-          return gcnew ActiveContextClr2Java(env, jobjectParentContext);
-        }
+						return gcnew ActiveContextClr2Java(env, jobjectParentContext);
+					}
 
-        String^ ClosedContextClr2Java::GetId() {
-          ManagedLog::LOGGER->Log("ClosedContextClr2Java::GetId");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringContextId);
-        }
+					String^ ClosedContextClr2Java::GetId() {
+						ManagedLog::LOGGER->Log("ClosedContextClr2Java::GetId");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringContextId);
+					}
 
-        String^ ClosedContextClr2Java::GetEvaluatorId() {
-          ManagedLog::LOGGER->Log("ClosedContextClr2Java::GetEvaluatorId");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringEvaluatorId);
-        }
+					String^ ClosedContextClr2Java::GetEvaluatorId() {
+						ManagedLog::LOGGER->Log("ClosedContextClr2Java::GetEvaluatorId");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringEvaluatorId);
+					}
 
-        IEvaluatorDescriptor^ ClosedContextClr2Java::GetEvaluatorDescriptor() {
-          ManagedLog::LOGGER->LogStart("ClosedContextClr2Java::GetEvaluatorDescriptor");
-          return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectClosedContext, _jvm);
-        }
+					IEvaluatorDescriptor^ ClosedContextClr2Java::GetEvaluatorDescriptor() {
+						ManagedLog::LOGGER->LogStart("ClosedContextClr2Java::GetEvaluatorDescriptor");
+						return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectClosedContext, _jvm);
+					}
 
-        void ClosedContextClr2Java::OnError(String^ message) {
-          ManagedLog::LOGGER->Log("ClosedContextClr2Java::OnError");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          HandleClr2JavaError(env, message, _jobjectClosedContext);
-        }
-      }
-    }
+					void ClosedContextClr2Java::OnError(String^ message) {
+						ManagedLog::LOGGER->Log("ClosedContextClr2Java::OnError");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						HandleClr2JavaError(env, message, _jobjectClosedContext);
+					}
+				}
+			}
+		}
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/Clr2JavaImpl.h
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/Clr2JavaImpl.h b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/Clr2JavaImpl.h
index b907c2a..41d6980 100644
--- a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/Clr2JavaImpl.h
+++ b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/Clr2JavaImpl.h
@@ -21,200 +21,202 @@
 #include "JavaClrBridge.h"
 #include "InteropAssemblies.h"
 #using "clrhandler.dll"
-#using "Microsoft.Reef.Driver.dll"
+#using "Org.Apache.Reef.Driver.dll"
 
 using namespace System;
 using namespace System::IO;
 using namespace System::Collections::Generic;
 using namespace System::Runtime::InteropServices;
 using namespace System::Reflection;
-using namespace Microsoft::Reef::Driver::Bridge;
-using namespace Microsoft::Reef::Driver::Evaluator;
-
-namespace Microsoft {
-  namespace Reef {
-    namespace Driver {
-      namespace Bridge {
-        public ref class CommonUtilities {
-          public:
-            static IEvaluatorDescriptor^ RetrieveEvaluatorDescriptor(jobject object, JavaVM* jvm);
-        };
-
-        public ref class AllocatedEvaluatorClr2Java : public IAllocatedEvaluaotrClr2Java {
-            jobject  _jobjectAllocatedEvaluator;
-            JavaVM* _jvm;
-            jstring _jstringId;
-            jstring _jstringNameServerInfo;
-          public:
-            AllocatedEvaluatorClr2Java(JNIEnv *env, jobject jallocatedEvaluator);
-            virtual void SubmitContextAndTask(String^ contextConfigStr, String^ taskConfigStr);
-            virtual void SubmitContext(String^ contextConfigStr);
-            virtual void SubmitContextAndService(String^ contextConfigStr, String^ serviceConfigStr);
-            virtual void SubmitContextAndServiceAndTask(String^ contextConfigStr, String^ serviceConfigStr, String^ taskConfigStr);
-            virtual void OnError(String^ message);
-            virtual void Close();
-            virtual String^ GetId();
-            virtual String^ GetNameServerInfo();
-            virtual IEvaluatorDescriptor^ GetEvaluatorDescriptor();
-        };
-
-        public ref class ActiveContextClr2Java : public IActiveContextClr2Java {
-            jobject _jobjectActiveContext;
-            jstring _jstringId;
-            jstring _jstringEvaluatorId;
-            JavaVM* _jvm;
-          public:
-            ActiveContextClr2Java(JNIEnv *env, jobject jallocatedEvaluator);
-            virtual void SubmitTask(String^ taskConfigStr);
-            virtual void Close();
-            virtual void OnError(String^ message);
-            virtual String^ GetId();
-            virtual String^ GetEvaluatorId();
-            virtual IEvaluatorDescriptor^ GetEvaluatorDescriptor();
-        };
-
-        public ref class EvaluatorRequestorClr2Java : public IEvaluatorRequestorClr2Java {
-            jobject  _jobjectEvaluatorRequestor;
-            JavaVM* _jvm;
-          public:
-            EvaluatorRequestorClr2Java(JNIEnv *env, jobject jevaluatorRequestor);
-            virtual void OnError(String^ message);
-            virtual void Submit(IEvaluatorRequest^ request);
-        };
-
-        public ref class TaskMessageClr2Java : public ITaskMessageClr2Java {
-            jobject  _jobjectTaskMessage;
-            JavaVM* _jvm;
-            jstring _jstringId;
-          public:
-            TaskMessageClr2Java(JNIEnv *env, jobject jtaskMessage);
-            virtual void OnError(String^ message);
-            virtual String^ GetId();
-        };
-
-        public ref class FailedTaskClr2Java : public IFailedTaskClr2Java {
-            jobject  _jobjectFailedTask;
-            JavaVM* _jvm;
-          public:
-            FailedTaskClr2Java(JNIEnv *env, jobject jfailedTask);
-            virtual void OnError(String^ message);
-            virtual IActiveContextClr2Java^ GetActiveContext();
-            virtual String^ GetString();
-        };
-
-        public ref class RunningTaskClr2Java : public IRunningTaskClr2Java {
-            jobject  _jobjectRunningTask;
-            JavaVM* _jvm;
-            jstring _jstringId;
-          public:
-            RunningTaskClr2Java(JNIEnv *env, jobject jrunningTask);
-            virtual void OnError(String^ message);
-            virtual IActiveContextClr2Java^ GetActiveContext();
-            virtual String^ GetId();
-            virtual void Send(array<byte>^ message);
-        };
-
-        public ref class FailedEvaluatorClr2Java : public IFailedEvaluatorClr2Java {
-            jobject  _jobjectFailedEvaluator;
-            JavaVM* _jvm;
-            jstring _jstringId;
-          public:
-            FailedEvaluatorClr2Java(JNIEnv *env, jobject jfailedEvaluator);
-            virtual void OnError(String^ message);
-            virtual IEvaluatorRequestorClr2Java^ GetEvaluatorRequestor();
-            virtual String^ GetId();
-        };
-
-        public ref class HttpServerClr2Java : public IHttpServerBridgeClr2Java {
-            jobject _jhttpServerEventBridge;
-            JavaVM* _jvm;
-          public:
-            HttpServerClr2Java(JNIEnv *env, jobject jhttpServerEventBridge);
-            virtual void OnError(String^ message);
-            virtual String^ GetQueryString();
-            virtual void SetUriSpecification(String^ uriSpecification);
-            virtual void SetQueryResult(String^ queryResult);
-            virtual array<byte>^ GetQueryRequestData();
-            virtual void SetQueryResponseData(array<byte>^ responseData);
-        };
-
-        public ref class CompletedTaskClr2Java : public ICompletedTaskClr2Java {
-            jobject  _jobjectCompletedTask;
-            JavaVM* _jvm;
-            jstring _jstringId;
-          public:
-            CompletedTaskClr2Java(JNIEnv *env, jobject jcompletedTask);
-            virtual void OnError(String^ message);
-            virtual IActiveContextClr2Java^ GetActiveContext();
-            virtual String^ GetId();
-        };
-
-        public ref class SuspendedTaskClr2Java : public ISuspendedTaskClr2Java {
-            jobject  _jobjectSuspendedTask;
-            JavaVM* _jvm;
-            jstring _jstringId;
-          public:
-            SuspendedTaskClr2Java(JNIEnv *env, jobject jobjectSuspendedTask);
-            virtual void OnError(String^ message);
-            virtual IActiveContextClr2Java^ GetActiveContext();
-            virtual String^ GetId();
-            virtual array<byte>^ Get();
-        };
-
-        public ref class CompletedEvaluatorClr2Java : public ICompletedEvaluatorClr2Java {
-            jobject  _jobjectCompletedEvaluator;
-            JavaVM* _jvm;
-            jstring _jstringId;
-          public:
-            CompletedEvaluatorClr2Java(JNIEnv *env, jobject jobjectCompletedEvaluator);
-            virtual void OnError(String^ message);
-            virtual String^ GetId();
-        };
-
-        public ref class ClosedContextClr2Java : public IClosedContextClr2Java {
-            jobject  _jobjectClosedContext;
-            JavaVM* _jvm;
-            jstring _jstringContextId;
-            jstring _jstringEvaluatorId;
-          public:
-            ClosedContextClr2Java(JNIEnv *env, jobject jobjectClosedContext);
-            virtual void OnError(String^ message);
-            virtual String^ GetId();
-            virtual String^ GetEvaluatorId();
-            virtual IEvaluatorDescriptor^ GetEvaluatorDescriptor();
-            virtual IActiveContextClr2Java^ GetParentContext();
-        };
-
-        public ref class FailedContextClr2Java : public IFailedContextClr2Java {
-            jobject  _jobjectFailedContext;
-            JavaVM* _jvm;
-            jstring _jstringContextId;
-            jstring _jstringEvaluatorId;
-            jstring _jstringParentContextId;
-          public:
-            FailedContextClr2Java(JNIEnv *env, jobject jobjectFailedContext);
-            virtual void OnError(String^ message);
-            virtual String^ GetId();
-            virtual String^ GetEvaluatorId();
-            virtual String^ GetParentId();
-            virtual IEvaluatorDescriptor^ GetEvaluatorDescriptor();
-            virtual IActiveContextClr2Java^ GetParentContext();
-        };
-
-        public ref class ContextMessageClr2Java : public IContextMessageClr2Java {
-            jobject  _jobjectContextMessage;
-            JavaVM* _jvm;
-            jbyteArray _jarrayMessage;
-            jstring _jstringId;
-            jstring _jstringSourceId;
-          public:
-            ContextMessageClr2Java(JNIEnv *env, jobject jobjectContextMessage);
-            virtual void OnError(String^ message);
-            virtual array<byte>^ Get();
-            virtual String^ GetId();
-            virtual String^ GetMessageSourceId();
-        };
-      }
-    }
+using namespace Org::Apache::Reef::Driver::Bridge;
+using namespace Org::Apache::Reef::Driver::Evaluator;
+
+namespace Org {
+  namespace Apache {
+		namespace Reef {
+			namespace Driver {
+				namespace Bridge {
+					public ref class CommonUtilities {
+						public:
+							static IEvaluatorDescriptor^ RetrieveEvaluatorDescriptor(jobject object, JavaVM* jvm);
+					};
+
+					public ref class AllocatedEvaluatorClr2Java : public IAllocatedEvaluaotrClr2Java {
+							jobject  _jobjectAllocatedEvaluator;
+							JavaVM* _jvm;
+							jstring _jstringId;
+							jstring _jstringNameServerInfo;
+						public:
+							AllocatedEvaluatorClr2Java(JNIEnv *env, jobject jallocatedEvaluator);
+							virtual void SubmitContextAndTask(String^ contextConfigStr, String^ taskConfigStr);
+							virtual void SubmitContext(String^ contextConfigStr);
+							virtual void SubmitContextAndService(String^ contextConfigStr, String^ serviceConfigStr);
+							virtual void SubmitContextAndServiceAndTask(String^ contextConfigStr, String^ serviceConfigStr, String^ taskConfigStr);
+							virtual void OnError(String^ message);
+							virtual void Close();
+							virtual String^ GetId();
+							virtual String^ GetNameServerInfo();
+							virtual IEvaluatorDescriptor^ GetEvaluatorDescriptor();
+					};
+
+					public ref class ActiveContextClr2Java : public IActiveContextClr2Java {
+							jobject _jobjectActiveContext;
+							jstring _jstringId;
+							jstring _jstringEvaluatorId;
+							JavaVM* _jvm;
+						public:
+							ActiveContextClr2Java(JNIEnv *env, jobject jallocatedEvaluator);
+							virtual void SubmitTask(String^ taskConfigStr);
+							virtual void Close();
+							virtual void OnError(String^ message);
+							virtual String^ GetId();
+							virtual String^ GetEvaluatorId();
+							virtual IEvaluatorDescriptor^ GetEvaluatorDescriptor();
+					};
+
+					public ref class EvaluatorRequestorClr2Java : public IEvaluatorRequestorClr2Java {
+							jobject  _jobjectEvaluatorRequestor;
+							JavaVM* _jvm;
+						public:
+							EvaluatorRequestorClr2Java(JNIEnv *env, jobject jevaluatorRequestor);
+							virtual void OnError(String^ message);
+							virtual void Submit(IEvaluatorRequest^ request);
+					};
+
+					public ref class TaskMessageClr2Java : public ITaskMessageClr2Java {
+							jobject  _jobjectTaskMessage;
+							JavaVM* _jvm;
+							jstring _jstringId;
+						public:
+							TaskMessageClr2Java(JNIEnv *env, jobject jtaskMessage);
+							virtual void OnError(String^ message);
+							virtual String^ GetId();
+					};
+
+					public ref class FailedTaskClr2Java : public IFailedTaskClr2Java {
+							jobject  _jobjectFailedTask;
+							JavaVM* _jvm;
+						public:
+							FailedTaskClr2Java(JNIEnv *env, jobject jfailedTask);
+							virtual void OnError(String^ message);
+							virtual IActiveContextClr2Java^ GetActiveContext();
+							virtual String^ GetString();
+					};
+
+					public ref class RunningTaskClr2Java : public IRunningTaskClr2Java {
+							jobject  _jobjectRunningTask;
+							JavaVM* _jvm;
+							jstring _jstringId;
+						public:
+							RunningTaskClr2Java(JNIEnv *env, jobject jrunningTask);
+							virtual void OnError(String^ message);
+							virtual IActiveContextClr2Java^ GetActiveContext();
+							virtual String^ GetId();
+							virtual void Send(array<byte>^ message);
+					};
+
+					public ref class FailedEvaluatorClr2Java : public IFailedEvaluatorClr2Java {
+							jobject  _jobjectFailedEvaluator;
+							JavaVM* _jvm;
+							jstring _jstringId;
+						public:
+							FailedEvaluatorClr2Java(JNIEnv *env, jobject jfailedEvaluator);
+							virtual void OnError(String^ message);
+							virtual IEvaluatorRequestorClr2Java^ GetEvaluatorRequestor();
+							virtual String^ GetId();
+					};
+
+					public ref class HttpServerClr2Java : public IHttpServerBridgeClr2Java {
+							jobject _jhttpServerEventBridge;
+							JavaVM* _jvm;
+						public:
+							HttpServerClr2Java(JNIEnv *env, jobject jhttpServerEventBridge);
+							virtual void OnError(String^ message);
+							virtual String^ GetQueryString();
+							virtual void SetUriSpecification(String^ uriSpecification);
+							virtual void SetQueryResult(String^ queryResult);
+							virtual array<byte>^ GetQueryRequestData();
+							virtual void SetQueryResponseData(array<byte>^ responseData);
+					};
+
+					public ref class CompletedTaskClr2Java : public ICompletedTaskClr2Java {
+							jobject  _jobjectCompletedTask;
+							JavaVM* _jvm;
+							jstring _jstringId;
+						public:
+							CompletedTaskClr2Java(JNIEnv *env, jobject jcompletedTask);
+							virtual void OnError(String^ message);
+							virtual IActiveContextClr2Java^ GetActiveContext();
+							virtual String^ GetId();
+					};
+
+					public ref class SuspendedTaskClr2Java : public ISuspendedTaskClr2Java {
+							jobject  _jobjectSuspendedTask;
+							JavaVM* _jvm;
+							jstring _jstringId;
+						public:
+							SuspendedTaskClr2Java(JNIEnv *env, jobject jobjectSuspendedTask);
+							virtual void OnError(String^ message);
+							virtual IActiveContextClr2Java^ GetActiveContext();
+							virtual String^ GetId();
+							virtual array<byte>^ Get();
+					};
+
+					public ref class CompletedEvaluatorClr2Java : public ICompletedEvaluatorClr2Java {
+							jobject  _jobjectCompletedEvaluator;
+							JavaVM* _jvm;
+							jstring _jstringId;
+						public:
+							CompletedEvaluatorClr2Java(JNIEnv *env, jobject jobjectCompletedEvaluator);
+							virtual void OnError(String^ message);
+							virtual String^ GetId();
+					};
+
+					public ref class ClosedContextClr2Java : public IClosedContextClr2Java {
+							jobject  _jobjectClosedContext;
+							JavaVM* _jvm;
+							jstring _jstringContextId;
+							jstring _jstringEvaluatorId;
+						public:
+							ClosedContextClr2Java(JNIEnv *env, jobject jobjectClosedContext);
+							virtual void OnError(String^ message);
+							virtual String^ GetId();
+							virtual String^ GetEvaluatorId();
+							virtual IEvaluatorDescriptor^ GetEvaluatorDescriptor();
+							virtual IActiveContextClr2Java^ GetParentContext();
+					};
+
+					public ref class FailedContextClr2Java : public IFailedContextClr2Java {
+							jobject  _jobjectFailedContext;
+							JavaVM* _jvm;
+							jstring _jstringContextId;
+							jstring _jstringEvaluatorId;
+							jstring _jstringParentContextId;
+						public:
+							FailedContextClr2Java(JNIEnv *env, jobject jobjectFailedContext);
+							virtual void OnError(String^ message);
+							virtual String^ GetId();
+							virtual String^ GetEvaluatorId();
+							virtual String^ GetParentId();
+							virtual IEvaluatorDescriptor^ GetEvaluatorDescriptor();
+							virtual IActiveContextClr2Java^ GetParentContext();
+					};
+
+					public ref class ContextMessageClr2Java : public IContextMessageClr2Java {
+							jobject  _jobjectContextMessage;
+							JavaVM* _jvm;
+							jbyteArray _jarrayMessage;
+							jstring _jstringId;
+							jstring _jstringSourceId;
+						public:
+							ContextMessageClr2Java(JNIEnv *env, jobject jobjectContextMessage);
+							virtual void OnError(String^ message);
+							virtual array<byte>^ Get();
+							virtual String^ GetId();
+							virtual String^ GetMessageSourceId();
+					};
+				}
+			}
+		}
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CommonUtilities.cpp
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CommonUtilities.cpp b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CommonUtilities.cpp
index c9b6cf1..c668dab 100644
--- a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CommonUtilities.cpp
+++ b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CommonUtilities.cpp
@@ -18,34 +18,36 @@
  */
 #include "Clr2JavaImpl.h"
 
-namespace Microsoft {
-  namespace Reef {
-    namespace Driver {
-      namespace Bridge {
-        ref class ManagedLog {
-          internal:
-            static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>CommonUtilities");
-        };
+namespace Org {
+  namespace Apache {
+		namespace Reef {
+			namespace Driver {
+				namespace Bridge {
+					ref class ManagedLog {
+						internal:
+							static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>CommonUtilities");
+					};
 
-        IEvaluatorDescriptor^ CommonUtilities::RetrieveEvaluatorDescriptor(jobject object, JavaVM* jvm) {
-          ManagedLog::LOGGER->LogStart("CommonUtilities::GetEvaluatorDescriptor");
-          JNIEnv *env = RetrieveEnv(jvm);
-          jclass jclassActiveContext = env->GetObjectClass (object);
-          jmethodID jmidGetEvaluatorDescriptor = env->GetMethodID(jclassActiveContext, "getEvaluatorDescriptorSring", "()Ljava/lang/String;");
+					IEvaluatorDescriptor^ CommonUtilities::RetrieveEvaluatorDescriptor(jobject object, JavaVM* jvm) {
+						ManagedLog::LOGGER->LogStart("CommonUtilities::GetEvaluatorDescriptor");
+						JNIEnv *env = RetrieveEnv(jvm);
+						jclass jclassActiveContext = env->GetObjectClass (object);
+						jmethodID jmidGetEvaluatorDescriptor = env->GetMethodID(jclassActiveContext, "getEvaluatorDescriptorSring", "()Ljava/lang/String;");
 
-          if (jmidGetEvaluatorDescriptor == NULL) {
-            ManagedLog::LOGGER->Log("jmidGetEvaluatorDescriptor is NULL");
-            return nullptr;
-          }
-          jstring jevaluatorDescriptorString = (jstring)env -> CallObjectMethod(
-                                                 object,
-                                                 jmidGetEvaluatorDescriptor);
-          String^ evaluatorDescriptorString = ManagedStringFromJavaString(env, jevaluatorDescriptorString);
-          ManagedLog::LOGGER->LogStop("InteropUtil::GetEvaluatorDescriptor");
+						if (jmidGetEvaluatorDescriptor == NULL) {
+							ManagedLog::LOGGER->Log("jmidGetEvaluatorDescriptor is NULL");
+							return nullptr;
+						}
+						jstring jevaluatorDescriptorString = (jstring)env -> CallObjectMethod(
+																									 object,
+																									 jmidGetEvaluatorDescriptor);
+						String^ evaluatorDescriptorString = ManagedStringFromJavaString(env, jevaluatorDescriptorString);
+						ManagedLog::LOGGER->LogStop("InteropUtil::GetEvaluatorDescriptor");
 
-          return gcnew EvaluatorDescriptorImpl(evaluatorDescriptorString);
-        }
-      }
-    }
+						return gcnew EvaluatorDescriptorImpl(evaluatorDescriptorString);
+					}
+				}
+			}
+		}
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CompletedEvaluatorClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CompletedEvaluatorClr2Java.cpp b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CompletedEvaluatorClr2Java.cpp
index 296670e..1bd9dbe 100644
--- a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CompletedEvaluatorClr2Java.cpp
+++ b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CompletedEvaluatorClr2Java.cpp
@@ -18,41 +18,43 @@
  */
 #include "Clr2JavaImpl.h"
 
-namespace Microsoft {
-  namespace Reef {
-    namespace Driver {
-      namespace Bridge {
-        ref class ManagedLog {
-          internal:
-            static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
-        };
+namespace Org {
+  namespace Apache {
+		namespace Reef {
+			namespace Driver {
+				namespace Bridge {
+					ref class ManagedLog {
+						internal:
+							static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+					};
 
-        CompletedEvaluatorClr2Java::CompletedEvaluatorClr2Java(JNIEnv *env, jobject jCompletedEvaluator) {
-          ManagedLog::LOGGER->LogStart("CompletedEvaluatorClr2Java::CompletedEvaluatorClr2Java");
-          pin_ptr<JavaVM*> pJavaVm = &_jvm;
-          if (env->GetJavaVM(pJavaVm) != 0) {
-            ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
-          }
-          _jobjectCompletedEvaluator = reinterpret_cast<jobject>(env->NewGlobalRef(jCompletedEvaluator));
+					CompletedEvaluatorClr2Java::CompletedEvaluatorClr2Java(JNIEnv *env, jobject jCompletedEvaluator) {
+						ManagedLog::LOGGER->LogStart("CompletedEvaluatorClr2Java::CompletedEvaluatorClr2Java");
+						pin_ptr<JavaVM*> pJavaVm = &_jvm;
+						if (env->GetJavaVM(pJavaVm) != 0) {
+							ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+						}
+						_jobjectCompletedEvaluator = reinterpret_cast<jobject>(env->NewGlobalRef(jCompletedEvaluator));
 
-          jclass jclassCompletedEvaluator = env->GetObjectClass (_jobjectCompletedEvaluator);
-          jfieldID jidEvaluatorId = env->GetFieldID(jclassCompletedEvaluator, "evaluatorId", "Ljava/lang/String;");
-          _jstringId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectCompletedEvaluator, jidEvaluatorId)));
-          ManagedLog::LOGGER->LogStop("CompletedEvaluatorClr2Java::CompletedEvaluatorClr2Java");
-        }
+						jclass jclassCompletedEvaluator = env->GetObjectClass (_jobjectCompletedEvaluator);
+						jfieldID jidEvaluatorId = env->GetFieldID(jclassCompletedEvaluator, "evaluatorId", "Ljava/lang/String;");
+						_jstringId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectCompletedEvaluator, jidEvaluatorId)));
+						ManagedLog::LOGGER->LogStop("CompletedEvaluatorClr2Java::CompletedEvaluatorClr2Java");
+					}
 
-        void CompletedEvaluatorClr2Java::OnError(String^ message) {
-          ManagedLog::LOGGER->Log("CompletedEvaluatorClr2Java::OnError");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          HandleClr2JavaError(env, message, _jobjectCompletedEvaluator);
-        }
+					void CompletedEvaluatorClr2Java::OnError(String^ message) {
+						ManagedLog::LOGGER->Log("CompletedEvaluatorClr2Java::OnError");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						HandleClr2JavaError(env, message, _jobjectCompletedEvaluator);
+					}
 
-        String^ CompletedEvaluatorClr2Java::GetId() {
-          ManagedLog::LOGGER->Log("CompletedEvaluatorClr2Java::GetId");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringId);
-        }
-      }
-    }
+					String^ CompletedEvaluatorClr2Java::GetId() {
+						ManagedLog::LOGGER->Log("CompletedEvaluatorClr2Java::GetId");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringId);
+					}
+				}
+			}
+		}
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CompletedTaskClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CompletedTaskClr2Java.cpp b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CompletedTaskClr2Java.cpp
index 631b2ea..ef7d9c7 100644
--- a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CompletedTaskClr2Java.cpp
+++ b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/CompletedTaskClr2Java.cpp
@@ -18,52 +18,54 @@
  */
 #include "Clr2JavaImpl.h"
 
-namespace Microsoft {
-  namespace Reef {
-    namespace Driver {
-      namespace Bridge {
-        ref class ManagedLog {
-          internal:
-            static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
-        };
+namespace Org {
+  namespace Apache {
+		namespace Reef {
+			namespace Driver {
+				namespace Bridge {
+					ref class ManagedLog {
+						internal:
+							static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+					};
 
-        CompletedTaskClr2Java::CompletedTaskClr2Java(JNIEnv *env, jobject jobjectCompletedTask) {
-          ManagedLog::LOGGER->LogStart("CompletedTaskClr2Java::CompletedTaskClr2Java");
-          pin_ptr<JavaVM*> pJavaVm = &_jvm;
-          if (env->GetJavaVM(pJavaVm) != 0) {
-            ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
-          }
-          _jobjectCompletedTask = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectCompletedTask));
+					CompletedTaskClr2Java::CompletedTaskClr2Java(JNIEnv *env, jobject jobjectCompletedTask) {
+						ManagedLog::LOGGER->LogStart("CompletedTaskClr2Java::CompletedTaskClr2Java");
+						pin_ptr<JavaVM*> pJavaVm = &_jvm;
+						if (env->GetJavaVM(pJavaVm) != 0) {
+							ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+						}
+						_jobjectCompletedTask = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectCompletedTask));
 
-          jclass jclassCompletedTask = env->GetObjectClass (_jobjectCompletedTask);
-          jfieldID jidTaskId = env->GetFieldID(jclassCompletedTask, "taskId", "Ljava/lang/String;");
-          _jstringId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectCompletedTask, jidTaskId)));
-          ManagedLog::LOGGER->LogStop("CompletedTaskClr2Java::CompletedTaskClr2Java");
-        }
+						jclass jclassCompletedTask = env->GetObjectClass (_jobjectCompletedTask);
+						jfieldID jidTaskId = env->GetFieldID(jclassCompletedTask, "taskId", "Ljava/lang/String;");
+						_jstringId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectCompletedTask, jidTaskId)));
+						ManagedLog::LOGGER->LogStop("CompletedTaskClr2Java::CompletedTaskClr2Java");
+					}
 
-        void CompletedTaskClr2Java::OnError(String^ message) {
-          ManagedLog::LOGGER->Log("CompletedTaskClr2Java::OnError");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          HandleClr2JavaError(env, message, _jobjectCompletedTask);
-        }
+					void CompletedTaskClr2Java::OnError(String^ message) {
+						ManagedLog::LOGGER->Log("CompletedTaskClr2Java::OnError");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						HandleClr2JavaError(env, message, _jobjectCompletedTask);
+					}
 
-        IActiveContextClr2Java^ CompletedTaskClr2Java::GetActiveContext() {
-          ManagedLog::LOGGER->LogStart("CompletedTaskClr2Java::GetActiveContext");
-          JNIEnv *env = RetrieveEnv(_jvm);
+					IActiveContextClr2Java^ CompletedTaskClr2Java::GetActiveContext() {
+						ManagedLog::LOGGER->LogStart("CompletedTaskClr2Java::GetActiveContext");
+						JNIEnv *env = RetrieveEnv(_jvm);
 
-          jclass jclassCompletedTask = env->GetObjectClass (_jobjectCompletedTask);
-          jfieldID jidActiveContext = env->GetFieldID(jclassCompletedTask, "jactiveContext", "Lorg/apache/reef/javabridge/ActiveContextBridge;");
-          jobject jobjectActiveContext = env->GetObjectField(_jobjectCompletedTask, jidActiveContext);
-          ManagedLog::LOGGER->LogStop("CompletedTaskClr2Java::GetActiveContext");
-          return gcnew ActiveContextClr2Java(env, jobjectActiveContext);
-        }
+						jclass jclassCompletedTask = env->GetObjectClass (_jobjectCompletedTask);
+						jfieldID jidActiveContext = env->GetFieldID(jclassCompletedTask, "jactiveContext", "Lorg/apache/reef/javabridge/ActiveContextBridge;");
+						jobject jobjectActiveContext = env->GetObjectField(_jobjectCompletedTask, jidActiveContext);
+						ManagedLog::LOGGER->LogStop("CompletedTaskClr2Java::GetActiveContext");
+						return gcnew ActiveContextClr2Java(env, jobjectActiveContext);
+					}
 
-        String^ CompletedTaskClr2Java::GetId() {
-          ManagedLog::LOGGER->Log("CompletedTaskClr2Java::GetId");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringId);
-        }
-      }
-    }
+					String^ CompletedTaskClr2Java::GetId() {
+						ManagedLog::LOGGER->Log("CompletedTaskClr2Java::GetId");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringId);
+					}
+				}
+			}
+		}
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ContextMessageClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ContextMessageClr2Java.cpp b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ContextMessageClr2Java.cpp
index 6f0834a..eda01f5 100644
--- a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ContextMessageClr2Java.cpp
+++ b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/ContextMessageClr2Java.cpp
@@ -18,59 +18,61 @@
  */
 #include "Clr2JavaImpl.h"
 
-namespace Microsoft {
-  namespace Reef {
-    namespace Driver {
-      namespace Bridge {
-        ref class ManagedLog {
-          internal:
-            static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
-        };
-        ContextMessageClr2Java::ContextMessageClr2Java(JNIEnv *env, jobject jobjectContextMessage) {
-          ManagedLog::LOGGER->LogStart("ContextMessageClr2Java::ContextMessageClr2Java");
+namespace Org {
+  namespace Apache {
+		namespace Reef {
+			namespace Driver {
+				namespace Bridge {
+					ref class ManagedLog {
+						internal:
+							static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+					};
+					ContextMessageClr2Java::ContextMessageClr2Java(JNIEnv *env, jobject jobjectContextMessage) {
+						ManagedLog::LOGGER->LogStart("ContextMessageClr2Java::ContextMessageClr2Java");
 
-          pin_ptr<JavaVM*> pJavaVm = &_jvm;
-          if (env->GetJavaVM(pJavaVm) != 0) {
-            ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
-          }
-          _jobjectContextMessage = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectContextMessage));
-          jclass jclassContextMessage = env->GetObjectClass (_jobjectContextMessage);
+						pin_ptr<JavaVM*> pJavaVm = &_jvm;
+						if (env->GetJavaVM(pJavaVm) != 0) {
+							ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+						}
+						_jobjectContextMessage = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectContextMessage));
+						jclass jclassContextMessage = env->GetObjectClass (_jobjectContextMessage);
 
-          jfieldID jidId = env->GetFieldID(jclassContextMessage, "contextMessageId", "Ljava/lang/String;");
-          jfieldID jidSourceId = env->GetFieldID(jclassContextMessage, "messageSourceId", "Ljava/lang/String;");
-          jfieldID jidMessage = env->GetFieldID(jclassContextMessage, "message", "()[B");
+						jfieldID jidId = env->GetFieldID(jclassContextMessage, "contextMessageId", "Ljava/lang/String;");
+						jfieldID jidSourceId = env->GetFieldID(jclassContextMessage, "messageSourceId", "Ljava/lang/String;");
+						jfieldID jidMessage = env->GetFieldID(jclassContextMessage, "message", "()[B");
 
-          _jstringId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectContextMessage, jidId)));
-          _jstringSourceId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectContextMessage, jidSourceId)));
-          _jarrayMessage = reinterpret_cast<jbyteArray>(env->NewGlobalRef(env->GetObjectField(_jobjectContextMessage, jidMessage)));
+						_jstringId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectContextMessage, jidId)));
+						_jstringSourceId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectContextMessage, jidSourceId)));
+						_jarrayMessage = reinterpret_cast<jbyteArray>(env->NewGlobalRef(env->GetObjectField(_jobjectContextMessage, jidMessage)));
 
-          ManagedLog::LOGGER->LogStop("ContextMessageClr2Java::ContextMessageClr2Java");
-        }
+						ManagedLog::LOGGER->LogStop("ContextMessageClr2Java::ContextMessageClr2Java");
+					}
 
-        String^ ContextMessageClr2Java::GetId() {
-          ManagedLog::LOGGER->Log("ContextMessageClr2Java::GetId");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringId);
-        }
+					String^ ContextMessageClr2Java::GetId() {
+						ManagedLog::LOGGER->Log("ContextMessageClr2Java::GetId");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringId);
+					}
 
-        String^ ContextMessageClr2Java::GetMessageSourceId() {
-          ManagedLog::LOGGER->Log("ContextMessageClr2Java::GetMessageSourceId");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringSourceId);
-        }
+					String^ ContextMessageClr2Java::GetMessageSourceId() {
+						ManagedLog::LOGGER->Log("ContextMessageClr2Java::GetMessageSourceId");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringSourceId);
+					}
 
-        array<byte>^ ContextMessageClr2Java::Get() {
-          ManagedLog::LOGGER->Log("ContextMessageClr2Java::Get");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedByteArrayFromJavaByteArray(env, _jarrayMessage);
-        }
+					array<byte>^ ContextMessageClr2Java::Get() {
+						ManagedLog::LOGGER->Log("ContextMessageClr2Java::Get");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedByteArrayFromJavaByteArray(env, _jarrayMessage);
+					}
 
-        void ContextMessageClr2Java::OnError(String^ message) {
-          ManagedLog::LOGGER->Log("ContextMessageClr2Java::OnError");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          HandleClr2JavaError(env, message, _jobjectContextMessage);
-        }
-      }
-    }
+					void ContextMessageClr2Java::OnError(String^ message) {
+						ManagedLog::LOGGER->Log("ContextMessageClr2Java::OnError");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						HandleClr2JavaError(env, message, _jobjectContextMessage);
+					}
+				}
+			}
+		}
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/EvaluatorRequestorClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/EvaluatorRequestorClr2Java.cpp b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/EvaluatorRequestorClr2Java.cpp
index eff8e3e..610f2a4 100644
--- a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/EvaluatorRequestorClr2Java.cpp
+++ b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/EvaluatorRequestorClr2Java.cpp
@@ -18,52 +18,54 @@
  */
 #include "Clr2JavaImpl.h"
 
-namespace Microsoft {
-  namespace Reef {
-    namespace Driver {
-      namespace Bridge {
-        ref class ManagedLog {
-          internal:
-            static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
-        };
+namespace Org {
+  namespace Apache {
+		namespace Reef {
+			namespace Driver {
+				namespace Bridge {
+					ref class ManagedLog {
+						internal:
+							static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+					};
 
-        EvaluatorRequestorClr2Java::EvaluatorRequestorClr2Java(JNIEnv *env, jobject jevaluatorRequestor) {
-          ManagedLog::LOGGER->LogStart("EvaluatorRequestorClr2Java::EvaluatorRequestorClr2Java");
-          pin_ptr<JavaVM*> pJavaVm = &_jvm;
-          if (env->GetJavaVM(pJavaVm) != 0) {
-            ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
-          }
-          _jobjectEvaluatorRequestor = reinterpret_cast<jobject>(env->NewGlobalRef(jevaluatorRequestor));
-          ManagedLog::LOGGER->LogStop("EvaluatorRequestorClr2Java::EvaluatorRequestorClr2Java");
-        }
+					EvaluatorRequestorClr2Java::EvaluatorRequestorClr2Java(JNIEnv *env, jobject jevaluatorRequestor) {
+						ManagedLog::LOGGER->LogStart("EvaluatorRequestorClr2Java::EvaluatorRequestorClr2Java");
+						pin_ptr<JavaVM*> pJavaVm = &_jvm;
+						if (env->GetJavaVM(pJavaVm) != 0) {
+							ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+						}
+						_jobjectEvaluatorRequestor = reinterpret_cast<jobject>(env->NewGlobalRef(jevaluatorRequestor));
+						ManagedLog::LOGGER->LogStop("EvaluatorRequestorClr2Java::EvaluatorRequestorClr2Java");
+					}
 
-        void EvaluatorRequestorClr2Java::Submit(IEvaluatorRequest^ request) {
-          ManagedLog::LOGGER->LogStart("EvaluatorRequestorClr2Java::Submit");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          jclass jclassEvaluatorRequestor = env->GetObjectClass (_jobjectEvaluatorRequestor);
-          jmethodID jmidSubmit = env->GetMethodID(jclassEvaluatorRequestor, "submit", "(IIILjava/lang/String;)V");
+					void EvaluatorRequestorClr2Java::Submit(IEvaluatorRequest^ request) {
+						ManagedLog::LOGGER->LogStart("EvaluatorRequestorClr2Java::Submit");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						jclass jclassEvaluatorRequestor = env->GetObjectClass (_jobjectEvaluatorRequestor);
+						jmethodID jmidSubmit = env->GetMethodID(jclassEvaluatorRequestor, "submit", "(IIILjava/lang/String;)V");
 
-          if (jmidSubmit == NULL) {
-            fprintf(stdout, " jmidSubmit is NULL\n");
-            fflush (stdout);
-            return;
-          }
-          env -> CallObjectMethod(
-            _jobjectEvaluatorRequestor,
-            jmidSubmit,
-            request -> Number,
-            request -> MemoryMegaBytes,
-			request -> VirtualCore,
-            JavaStringFromManagedString(env, request -> Rack));
-          ManagedLog::LOGGER->LogStop("EvaluatorRequestorClr2Java::Submit");
-        }
+						if (jmidSubmit == NULL) {
+							fprintf(stdout, " jmidSubmit is NULL\n");
+							fflush (stdout);
+							return;
+						}
+						env -> CallObjectMethod(
+							_jobjectEvaluatorRequestor,
+							jmidSubmit,
+							request -> Number,
+							request -> MemoryMegaBytes,
+				request -> VirtualCore,
+							JavaStringFromManagedString(env, request -> Rack));
+						ManagedLog::LOGGER->LogStop("EvaluatorRequestorClr2Java::Submit");
+					}
 
-        void EvaluatorRequestorClr2Java::OnError(String^ message) {
-          ManagedLog::LOGGER->Log("EvaluatorRequestorClr2Java::OnError");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          HandleClr2JavaError(env, message, _jobjectEvaluatorRequestor);
-        }
-      }
-    }
+					void EvaluatorRequestorClr2Java::OnError(String^ message) {
+						ManagedLog::LOGGER->Log("EvaluatorRequestorClr2Java::OnError");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						HandleClr2JavaError(env, message, _jobjectEvaluatorRequestor);
+					}
+				}
+			}
+		}
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/FailedContextClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/FailedContextClr2Java.cpp b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/FailedContextClr2Java.cpp
index 9a6e6d8..6dee54f 100644
--- a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/FailedContextClr2Java.cpp
+++ b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/FailedContextClr2Java.cpp
@@ -18,77 +18,79 @@
  */
 #include "Clr2JavaImpl.h"
 
-namespace Microsoft {
-  namespace Reef {
-    namespace Driver {
-      namespace Bridge {
-        ref class ManagedLog {
-          internal:
-            static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
-        };
-        FailedContextClr2Java::FailedContextClr2Java(JNIEnv *env, jobject jobjectFailedContext) {
-          ManagedLog::LOGGER->LogStart("FailedContextClr2Java::FailedContextClr2Java");
+namespace Org {
+  namespace Apache {
+		namespace Reef {
+			namespace Driver {
+				namespace Bridge {
+					ref class ManagedLog {
+						internal:
+							static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+					};
+					FailedContextClr2Java::FailedContextClr2Java(JNIEnv *env, jobject jobjectFailedContext) {
+						ManagedLog::LOGGER->LogStart("FailedContextClr2Java::FailedContextClr2Java");
 
-          pin_ptr<JavaVM*> pJavaVm = &_jvm;
-          if (env->GetJavaVM(pJavaVm) != 0) {
-            ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
-          }
-          _jobjectFailedContext = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectFailedContext));
-          jclass jclassFailedContext = env->GetObjectClass (_jobjectFailedContext);
+						pin_ptr<JavaVM*> pJavaVm = &_jvm;
+						if (env->GetJavaVM(pJavaVm) != 0) {
+							ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+						}
+						_jobjectFailedContext = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectFailedContext));
+						jclass jclassFailedContext = env->GetObjectClass (_jobjectFailedContext);
 
-          jfieldID jidContextId = env->GetFieldID(jclassFailedContext, "contextId", "Ljava/lang/String;");
-          jfieldID jidEvaluatorId = env->GetFieldID(jclassFailedContext, "evaluatorId", "Ljava/lang/String;");
-          jfieldID jidParentId = env->GetFieldID(jclassFailedContext, "parentContextId", "Ljava/lang/String;");
+						jfieldID jidContextId = env->GetFieldID(jclassFailedContext, "contextId", "Ljava/lang/String;");
+						jfieldID jidEvaluatorId = env->GetFieldID(jclassFailedContext, "evaluatorId", "Ljava/lang/String;");
+						jfieldID jidParentId = env->GetFieldID(jclassFailedContext, "parentContextId", "Ljava/lang/String;");
 
-          _jstringContextId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectFailedContext, jidContextId)));
-          _jstringEvaluatorId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectFailedContext, jidEvaluatorId)));
-          _jstringParentContextId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectFailedContext, jidParentId)));
+						_jstringContextId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectFailedContext, jidContextId)));
+						_jstringEvaluatorId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectFailedContext, jidEvaluatorId)));
+						_jstringParentContextId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectFailedContext, jidParentId)));
 
-          ManagedLog::LOGGER->LogStop("FailedContextClr2Java::FailedContextClr2Java");
-        }
+						ManagedLog::LOGGER->LogStop("FailedContextClr2Java::FailedContextClr2Java");
+					}
 
-        IActiveContextClr2Java^ FailedContextClr2Java::GetParentContext() {
-          ManagedLog::LOGGER->LogStart("FailedContextClr2Java::GetParentContext");
+					IActiveContextClr2Java^ FailedContextClr2Java::GetParentContext() {
+						ManagedLog::LOGGER->LogStart("FailedContextClr2Java::GetParentContext");
 
-          JNIEnv *env = RetrieveEnv(_jvm);
+						JNIEnv *env = RetrieveEnv(_jvm);
 
-          jclass jclassFailedContext = env->GetObjectClass(_jobjectFailedContext);
-          jfieldID jidParentContext = env->GetFieldID(jclassFailedContext, "parentContext", "Lorg/apache/reef/javabridge/ActiveContextBridge;");
-          jobject jobjectParentContext = env->GetObjectField(_jobjectFailedContext, jidParentContext);
-          ManagedLog::LOGGER->LogStop("FailedContextClr2Java::GetParentContext");
+						jclass jclassFailedContext = env->GetObjectClass(_jobjectFailedContext);
+						jfieldID jidParentContext = env->GetFieldID(jclassFailedContext, "parentContext", "Lorg/apache/reef/javabridge/ActiveContextBridge;");
+						jobject jobjectParentContext = env->GetObjectField(_jobjectFailedContext, jidParentContext);
+						ManagedLog::LOGGER->LogStop("FailedContextClr2Java::GetParentContext");
 
-          return gcnew ActiveContextClr2Java(env, jobjectParentContext);
-        }
+						return gcnew ActiveContextClr2Java(env, jobjectParentContext);
+					}
 
-        String^ FailedContextClr2Java::GetId() {
-          ManagedLog::LOGGER->Log("FailedContextClr2Java::GetId");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringContextId);
-        }
+					String^ FailedContextClr2Java::GetId() {
+						ManagedLog::LOGGER->Log("FailedContextClr2Java::GetId");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringContextId);
+					}
 
-        String^ FailedContextClr2Java::GetEvaluatorId() {
-          ManagedLog::LOGGER->Log("FailedContextClr2Java::GetEvaluatorId");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringEvaluatorId);
-        }
+					String^ FailedContextClr2Java::GetEvaluatorId() {
+						ManagedLog::LOGGER->Log("FailedContextClr2Java::GetEvaluatorId");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringEvaluatorId);
+					}
 
-        String^ FailedContextClr2Java::GetParentId() {
-          ManagedLog::LOGGER->Log("FailedContextClr2Java::GetParentId");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringParentContextId);
-        }
+					String^ FailedContextClr2Java::GetParentId() {
+						ManagedLog::LOGGER->Log("FailedContextClr2Java::GetParentId");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringParentContextId);
+					}
 
-        IEvaluatorDescriptor^ FailedContextClr2Java::GetEvaluatorDescriptor() {
-          ManagedLog::LOGGER->LogStart("FailedContextClr2Java::GetEvaluatorDescriptor");
-          return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectFailedContext, _jvm);
-        }
+					IEvaluatorDescriptor^ FailedContextClr2Java::GetEvaluatorDescriptor() {
+						ManagedLog::LOGGER->LogStart("FailedContextClr2Java::GetEvaluatorDescriptor");
+						return CommonUtilities::RetrieveEvaluatorDescriptor(_jobjectFailedContext, _jvm);
+					}
 
-        void FailedContextClr2Java::OnError(String^ message) {
-          ManagedLog::LOGGER->Log("FailedContextClr2Java::OnError");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          HandleClr2JavaError(env, message, _jobjectFailedContext);
-        }
-      }
-    }
+					void FailedContextClr2Java::OnError(String^ message) {
+						ManagedLog::LOGGER->Log("FailedContextClr2Java::OnError");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						HandleClr2JavaError(env, message, _jobjectFailedContext);
+					}
+				}
+			}
+		}
   }
 }
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/incubator-reef/blob/5cc60715/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/FailedEvaluatorClr2Java.cpp
----------------------------------------------------------------------
diff --git a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/FailedEvaluatorClr2Java.cpp b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/FailedEvaluatorClr2Java.cpp
index d79ecce..60e4b1c 100644
--- a/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/FailedEvaluatorClr2Java.cpp
+++ b/lang/java/reef-bridge-project/reef-bridge-clr/src/main/Cpp/CppBridge/JavaClrBridge/FailedEvaluatorClr2Java.cpp
@@ -20,53 +20,55 @@
 
 using namespace JavaClrBridge;
 
-namespace Microsoft {
-  namespace Reef {
-    namespace Driver {
-      namespace Bridge {
-        ref class ManagedLog {
-          internal:
-            static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
-        };
+namespace Org {
+  namespace Apache {
+		namespace Reef {
+			namespace Driver {
+				namespace Bridge {
+					ref class ManagedLog {
+						internal:
+							static BridgeLogger^ LOGGER = BridgeLogger::GetLogger("<C++>");
+					};
 
-        FailedEvaluatorClr2Java::FailedEvaluatorClr2Java(JNIEnv *env, jobject jobjectFailedEvaluator) {
-          ManagedLog::LOGGER->LogStart("FailedEvaluatorClr2Java::FailedEvaluatorClr2Java");
-          pin_ptr<JavaVM*> pJavaVm = &_jvm;
-          if (env->GetJavaVM(pJavaVm) != 0) {
-            ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
-          }
-          _jobjectFailedEvaluator = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectFailedEvaluator));
+					FailedEvaluatorClr2Java::FailedEvaluatorClr2Java(JNIEnv *env, jobject jobjectFailedEvaluator) {
+						ManagedLog::LOGGER->LogStart("FailedEvaluatorClr2Java::FailedEvaluatorClr2Java");
+						pin_ptr<JavaVM*> pJavaVm = &_jvm;
+						if (env->GetJavaVM(pJavaVm) != 0) {
+							ManagedLog::LOGGER->LogError("Failed to get JavaVM", nullptr);
+						}
+						_jobjectFailedEvaluator = reinterpret_cast<jobject>(env->NewGlobalRef(jobjectFailedEvaluator));
 
-          jclass jclassFailedEvaluator = env->GetObjectClass(_jobjectFailedEvaluator);
-          jfieldID jidEvaluatorId = env->GetFieldID(jclassFailedEvaluator, "evaluatorId", "Ljava/lang/String;");
-          _jstringId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectFailedEvaluator, jidEvaluatorId)));
-          ManagedLog::LOGGER->LogStop("FailedEvaluatorClr2Java::FailedEvaluatorClr2Java");
-        }
+						jclass jclassFailedEvaluator = env->GetObjectClass(_jobjectFailedEvaluator);
+						jfieldID jidEvaluatorId = env->GetFieldID(jclassFailedEvaluator, "evaluatorId", "Ljava/lang/String;");
+						_jstringId = reinterpret_cast<jstring>(env->NewGlobalRef(env->GetObjectField(_jobjectFailedEvaluator, jidEvaluatorId)));
+						ManagedLog::LOGGER->LogStop("FailedEvaluatorClr2Java::FailedEvaluatorClr2Java");
+					}
 
-        IEvaluatorRequestorClr2Java^ FailedEvaluatorClr2Java::GetEvaluatorRequestor() {
-          ManagedLog::LOGGER->LogStart("FailedEvaluatorClr2Java::GetEvaluatorRequestor");
-          JNIEnv *env = RetrieveEnv(_jvm);
+					IEvaluatorRequestorClr2Java^ FailedEvaluatorClr2Java::GetEvaluatorRequestor() {
+						ManagedLog::LOGGER->LogStart("FailedEvaluatorClr2Java::GetEvaluatorRequestor");
+						JNIEnv *env = RetrieveEnv(_jvm);
 
-          jclass jclassFailedEvaluator = env->GetObjectClass(_jobjectFailedEvaluator);
-          jfieldID jidEvaluatorRequestor = env->GetFieldID(jclassFailedEvaluator, "evaluatorRequestorBridge", "Lorg/apache/reef/javabridge/EvaluatorRequestorBridge;");
-          jobject jobjectEvaluatorRequestor = env->GetObjectField(_jobjectFailedEvaluator, jidEvaluatorRequestor);
-          ManagedLog::LOGGER->LogStop("FailedEvaluatorClr2Java::GetEvaluatorRequestor");
-          return gcnew EvaluatorRequestorClr2Java(env, jobjectEvaluatorRequestor);
-        }
+						jclass jclassFailedEvaluator = env->GetObjectClass(_jobjectFailedEvaluator);
+						jfieldID jidEvaluatorRequestor = env->GetFieldID(jclassFailedEvaluator, "evaluatorRequestorBridge", "Lorg/apache/reef/javabridge/EvaluatorRequestorBridge;");
+						jobject jobjectEvaluatorRequestor = env->GetObjectField(_jobjectFailedEvaluator, jidEvaluatorRequestor);
+						ManagedLog::LOGGER->LogStop("FailedEvaluatorClr2Java::GetEvaluatorRequestor");
+						return gcnew EvaluatorRequestorClr2Java(env, jobjectEvaluatorRequestor);
+					}
 
-        String^ FailedEvaluatorClr2Java::GetId() {
-          ManagedLog::LOGGER->Log("FailedEvaluatorClr2Java::GetId");
+					String^ FailedEvaluatorClr2Java::GetId() {
+						ManagedLog::LOGGER->Log("FailedEvaluatorClr2Java::GetId");
 
-          JNIEnv *env = RetrieveEnv(_jvm);
-          return ManagedStringFromJavaString(env, _jstringId);
-        }
+						JNIEnv *env = RetrieveEnv(_jvm);
+						return ManagedStringFromJavaString(env, _jstringId);
+					}
 
-        void FailedEvaluatorClr2Java::OnError(String^ message) {
-          ManagedLog::LOGGER->Log("FailedEvaluatorClr2Java::OnError");
-          JNIEnv *env = RetrieveEnv(_jvm);
-          HandleClr2JavaError(env, message, _jobjectFailedEvaluator);
-        }
-      }
-    }
+					void FailedEvaluatorClr2Java::OnError(String^ message) {
+						ManagedLog::LOGGER->Log("FailedEvaluatorClr2Java::OnError");
+						JNIEnv *env = RetrieveEnv(_jvm);
+						HandleClr2JavaError(env, message, _jobjectFailedEvaluator);
+					}
+				}
+			}
+		}
   }
 }
\ No newline at end of file