void QueryCursorImpl::GetNext(OutputOperation& op, IgniteError& err)
{
// Check whether GetAll() was called earlier.
if (getAllCalled)
{
err = IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Cannot use GetNext() method because GetAll() was called.");
return;
}
// Create iterator in Java if needed.
if (!CreateIteratorIfNeeded(err))
return;
// Get next results batch if the end in the current batch
// has been reached.
if (!GetNextBatchIfNeeded(err))
return;
if (endReached)
{
// Ensure we do not overwrite possible previous error.
if (err.GetCode() == IgniteError::IGNITE_SUCCESS)
err = IgniteError(IgniteError::IGNITE_ERR_GENERIC, "No more elements available.");
return;
}
batch->GetNext(op);
}
void Transaction::Rollback(IgniteError & err)
{
err = IgniteError();
TransactionImpl* txImpl = impl.Get();
if (txImpl)
txImpl->Rollback(err);
else
{
err = IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Instance is not usable (did you check for error?).");
}
}
TransactionState::Type Transaction::GetState(IgniteError& err)
{
err = IgniteError();
TransactionImpl* txImpl = impl.Get();
if (txImpl)
return txImpl->GetState(err);
else
{
err = IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Instance is not usable (did you check for error?).");
}
return TransactionState::UNKNOWN;
}
bool Transaction::IsRollbackOnly(IgniteError& err)
{
err = IgniteError();
TransactionImpl* txImpl = impl.Get();
if (txImpl)
return txImpl->IsRollbackOnly(err);
else
{
err = IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Instance is not usable (did you check for error?).");
}
return false;
}
void GetLocalAddresses(std::set<std::string>& addrs)
{
IP_ADAPTER_ADDRESSES outAddrs[64];
DWORD outAddrsSize = sizeof(outAddrs);
DWORD error = ::GetAdaptersAddresses(AF_UNSPEC, 0, NULL, &outAddrs[0], &outAddrsSize);
if (ERROR_SUCCESS != error)
throw IgniteError(IgniteError::IGNITE_ERR_GENERIC, "Error getting local addresses list");
for (IP_ADAPTER_ADDRESSES* outAddr = &outAddrs[0]; NULL != outAddr; outAddr = outAddr->Next)
{
if (IF_TYPE_SOFTWARE_LOOPBACK == outAddr->IfType)
continue;
for (IP_ADAPTER_UNICAST_ADDRESS* addr = outAddr->FirstUnicastAddress;
NULL != addr;
addr = addr->Next)
{
void *inAddr = 0;
char strBuffer[INET6_ADDRSTRLEN] = { 0 };
int saFamily = addr->Address.lpSockaddr->sa_family;
switch (saFamily)
{
case AF_INET:
{
SOCKADDR_IN* ipv4 = reinterpret_cast<SOCKADDR_IN*>(addr->Address.lpSockaddr);
inAddr = &ipv4->sin_addr;
break;
}
case AF_INET6:
{
SOCKADDR_IN6* ipv6 = reinterpret_cast<SOCKADDR_IN6*>(addr->Address.lpSockaddr);
inAddr = &ipv6->sin6_addr;
break;
}
default:
continue;
}
inet_ntop(saFamily, inAddr, strBuffer, sizeof(strBuffer));
std::string strAddr(strBuffer);
if (!strAddr.empty())
addrs.insert(strAddr);
}
}
}
void Configuration::ParseAddress(const std::string& address, EndPoint& res)
{
int64_t colonNum = std::count(address.begin(), address.end(), ':');
if (colonNum == 0)
{
res.host = address;
res.port = DefaultValue::port;
}
else if (colonNum == 1)
{
size_t pos = address.find(':');
if (pos == address.size() - 1)
throw IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Invalid address format: no port after colon");
res.host = address.substr(0, pos);
std::string port = address.substr(pos + 1);
if (!common::AllOf(port.begin(), port.end(), isdigit))
throw IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Invalid address format: port can only contain digits");
int32_t intPort = common::LexicalCast<int32_t>(port);
if (port.size() > sizeof("65535") - 1 || intPort > UINT16_MAX)
{
throw IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Invalid address format: Port value is too large,"
" valid value should be in range from 1 to 65535");
}
if (intPort == 0)
throw IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Invalid address format: Port value can not be zero");
res.port = static_cast<uint16_t>(intPort);
}
else
throw IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Invalid address format: too many colons");
}
void QueryCursorImpl::GetAll(OutputOperation& op, IgniteError& err)
{
// Check whether any of iterator methods were called.
if (iterCalled)
{
err = IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Cannot use GetAll() method because an iteration method was called.");
return;
}
// Check whether GetAll was called before.
if (getAllCalled)
{
err = IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Cannot use GetNext() method because GetAll() was called.");
return;
}
// Get data.
JniErrorInfo jniErr;
SharedPointer<InteropMemory> inMem = env.Get()->AllocateMemory();
env.Get()->Context()->TargetOutStream(javaRef, OP_GET_ALL, inMem.Get()->PointerLong(), &jniErr);
IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
if (jniErr.code == IGNITE_JNI_ERR_SUCCESS)
{
getAllCalled = true;
InteropInputStream in(inMem.Get());
BinaryReaderImpl reader(&in);
op.ProcessOutput(reader);
}
}
void ThrowLastSetupError()
{
DWORD code;
char msg[BUFFER_SIZE];
SQLInstallerError(1, &code, msg, sizeof(msg), NULL);
std::stringstream buf;
buf << "Message: \"" << msg << "\", Code: " << code;
throw IgniteError(IgniteError::IGNITE_ERR_GENERIC, buf.str().c_str());
}
bool QueryCursorImpl::HasNext(IgniteError& err)
{
// Check whether GetAll() was called earlier.
if (getAllCalled)
{
err = IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Cannot use HasNext() method because GetAll() was called.");
return false;
}
// Create iterator in Java if needed.
if (!CreateIteratorIfNeeded(err))
return false;
// Get next results batch if the end in the current batch
// has been reached.
if (!GetNextBatchIfNeeded(err))
return false;
return !endReached;
}
QueryFieldsRowImpl* QueryCursorImpl::GetNextRow(IgniteError& err)
{
// Create iterator in Java if needed.
if (!CreateIteratorIfNeeded(err))
return 0;
// Get next results batch if the end in the current batch
// has been reached.
if (!GetNextBatchIfNeeded(err))
return 0;
if (endReached)
{
// Ensure we do not overwrite possible previous error.
if (err.GetCode() == IgniteError::IGNITE_SUCCESS)
err = IgniteError(IgniteError::IGNITE_ERR_GENERIC, "No more elements available.");
return 0;
}
return batch->GetNextRow();
}
Ignite Ignition::Get(const char* name, IgniteError* err)
{
Ignite res;
factoryLock.Enter();
if (started)
{
char* name0 = CopyChars(name);
// 1. Create context for this operation.
JniErrorInfo jniErr;
SharedPointer<JniContext> ctx(JniContext::Create(NULL, 0, JniHandlers(), &jniErr));
IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
if (err->GetCode() == IgniteError::IGNITE_SUCCESS)
{
// 2. Get environment pointer.
long long ptr = ctx.Get()->IgnitionEnvironmentPointer(name0, &jniErr);
IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
if (err->GetCode() == IgniteError::IGNITE_SUCCESS)
{
if (ptr != 0)
{
// 3. Obtain real environment for this instance.
JniHandlers* hnds = reinterpret_cast<JniHandlers*>(ptr);
SharedPointer<IgniteEnvironment>* env =
static_cast<SharedPointer<IgniteEnvironment>*>(hnds->target);
// 4. Get fresh node reference.
jobject ref = ctx.Get()->IgnitionInstance(name0, &jniErr);
if (err->GetCode() == IgniteError::IGNITE_SUCCESS) {
if (ref)
{
IgniteImpl* impl = new IgniteImpl(*env, ref);
res = Ignite(impl);
}
else
// Error: concurrent node stop.
*err = IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Failed to get Ignite instance because it was stopped concurrently.");
}
}
else
// Error: no node with the given name.
*err = IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Failed to get Ignite instance because it is either not started yet or already stopped.");
}
}
ReleaseChars(name0);
}
else
// Error: no node with the given name.
*err = IgniteError(IgniteError::IGNITE_ERR_GENERIC,
"Failed to get Ignite instance because it is either not started yet or already stopped.");
factoryLock.Leave();
return res;
}
Ignite Ignition::Start(const IgniteConfiguration& cfg, const char* name, IgniteError* err)
{
bool failed = false;
SharedPointer<IgniteEnvironment> env;
SharedPointer<IgniteEnvironment>* envTarget = NULL;
jobject javaRef = NULL;
factoryLock.Enter();
// 1. Load JVM library if needed.
if (!JVM_LIB_LOADED)
{
bool jvmLibFound;
std::string jvmLib;
if (cfg.jvmLibPath)
{
std::string jvmLibPath = std::string(cfg.jvmLibPath);
jvmLib = FindJvmLibrary(&jvmLibPath, &jvmLibFound);
}
else
jvmLib = FindJvmLibrary(NULL, &jvmLibFound);
if (!jvmLibFound)
{
*err = IgniteError(IgniteError::IGNITE_ERR_JVM_LIB_NOT_FOUND,
"JVM library is not found (did you set JAVA_HOME environment variable?)");
failed = true;
}
if (!failed) {
if (!LoadJvmLibrary(jvmLib))
{
*err = IgniteError(IgniteError::IGNITE_ERR_JVM_LIB_LOAD_FAILED, "Failed to load JVM library.");
failed = true;
}
}
JVM_LIB_LOADED = true;
}
if (!failed)
{
// 2. Resolve IGNITE_HOME.
bool homeFound;
std::string home;
if (cfg.igniteHome)
{
std::string homePath = std::string(cfg.igniteHome);
home = ResolveIgniteHome(&homePath, &homeFound);
}
else
home = ResolveIgniteHome(NULL, &homeFound);
// 3. Create classpath.
std::string cp;
if (cfg.jvmClassPath)
{
std::string usrCp = cfg.jvmClassPath;
cp = CreateIgniteClasspath(&usrCp, homeFound ? &home : NULL);
}
else
cp = CreateIgniteClasspath(NULL, homeFound ? &home : NULL);
if (!cp.empty())
{
// 4. Start JVM if needed.
JniErrorInfo jniErr;
env = SharedPointer<IgniteEnvironment>(new IgniteEnvironment());
int optsLen;
char** opts = CreateJvmOptions(cfg, homeFound ? &home : NULL, cp, &optsLen);
envTarget = new SharedPointer<IgniteEnvironment>(env);
SharedPointer<JniContext> ctx(
JniContext::Create(opts, optsLen, env.Get()->GetJniHandlers(envTarget), &jniErr));
for (int i = 0; i < optsLen; i++)
ReleaseChars(*(opts + i));
delete[] opts;
if (!ctx.Get())
{
IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
failed = true;
}
// 5. Start Ignite.
if (!failed)
{
char* springCfgPath0 = CopyChars(cfg.springCfgPath);
if (!springCfgPath0)
springCfgPath0 = CopyChars(DFLT_CFG);
char* name0 = CopyChars(name);
interop::InteropUnpooledMemory mem(16);
interop::InteropOutputStream stream(&mem);
stream.WriteBool(false);
stream.Synchronize();
javaRef = ctx.Get()->IgnitionStart(springCfgPath0, name0, 2, mem.PointerLong(), &jniErr);
ReleaseChars(springCfgPath0);
ReleaseChars(name0);
if (!javaRef) {
IgniteError::SetError(jniErr.code, jniErr.errCls, jniErr.errMsg, err);
failed = true;
}
else {
// 6. Ignite is started at this point.
env.Get()->Initialize(ctx);
started = true;
}
}
}
else {
*err = IgniteError(IgniteError::IGNITE_ERR_JVM_NO_CLASSPATH,
"Java classpath is empty (did you set IGNITE_HOME environment variable?)");
failed = true;
}
}
factoryLock.Leave();
if (failed)
{
if (envTarget)
delete envTarget;
return Ignite();
}
else
{
IgniteImpl* impl = new IgniteImpl(env, javaRef);
return Ignite(impl);
}
}
int32_t BinaryObjectImpl::GetEnumValue() const
{
throw IgniteError(IgniteError::IGNITE_ERR_BINARY, "GetEnumValue is only supported for enums.");
}
bool TcpSocketClient::Connect(const char* hostname, uint16_t port, int32_t timeout)
{
static common::concurrent::CriticalSection initCs;
static bool networkInited = false;
// Initing networking if is not inited.
if (!networkInited)
{
common::concurrent::CsLockGuard lock(initCs);
if (!networkInited)
{
WSADATA wsaData;
networkInited = (WSAStartup(MAKEWORD(2, 2), &wsaData) == 0);
if (!networkInited)
{
std::string err = "Networking initialisation failed: " + GetLastSocketErrorMessage();
throw IgniteError(IgniteError::IGNITE_ERR_GENERIC, err.c_str());
}
}
}
addrinfo hints = { 0 };
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
std::stringstream converter;
converter << port;
// Resolve the server address and port
addrinfo *result = NULL;
int res = getaddrinfo(hostname, converter.str().c_str(), &hints, &result);
if (res != 0)
return false;
// Attempt to connect to an address until one succeeds
for (addrinfo *it = result; it != NULL; it = it->ai_next)
{
// Create a SOCKET for connecting to server
socketHandle = socket(it->ai_family, it->ai_socktype, it->ai_protocol);
if (socketHandle == INVALID_SOCKET)
{
std::string err = "Socket creation failed: " + GetLastSocketErrorMessage();
throw IgniteError(IgniteError::IGNITE_ERR_GENERIC, err.c_str());
}
TrySetOptions();
// Connect to server.
res = connect(socketHandle, it->ai_addr, static_cast<int>(it->ai_addrlen));
if (SOCKET_ERROR == res)
{
int lastError = WSAGetLastError();
if (lastError != WSAEWOULDBLOCK)
{
Close();
continue;
}
res = WaitOnSocket(timeout, false);
if (res < 0 || res == WaitResult::TIMEOUT)
{
Close();
continue;
}
}
break;
}
freeaddrinfo(result);
return socketHandle != INVALID_SOCKET;
}
