[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16015831#comment-16015831
]
Valentin Kulichenko commented on IGNITE-4205:
-
Looks like this scenario is not applicable to POJO store. The fix can be merged.
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Konstantin Dudkov
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16013686#comment-16013686
]
Valentin Kulichenko commented on IGNITE-4205:
-
That's not true. JDBC store does work with binary objects, at least when there
are no classes on server nodes.
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Konstantin Dudkov
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16013678#comment-16013678
]
Konstantin Dudkov commented on IGNITE-4205:
---
In CacheAbstractJdbcStore it was the thread naming question only - because the
only child class - CacheJdbcPojoStore - doesn't use binary marshaller. So I can
test only the fact that new threads are instances of IgniteThread, that is
obvious.
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Konstantin Dudkov
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16012478#comment-16012478
]
Valentin Kulichenko commented on IGNITE-4205:
-
Can you add test for it as well?
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Konstantin Dudkov
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16012218#comment-16012218
]
Konstantin Dudkov commented on IGNITE-4205:
---
I've fixed this issue in CacheAbstractJdbcStore too.
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Konstantin Dudkov
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16012194#comment-16012194
]
Valentin Kulichenko commented on IGNITE-4205:
-
I don't think it makes sense to separate these fixes. Can you fix the JDBC
store in the same PR?
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Konstantin Dudkov
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16012065#comment-16012065
]
Konstantin Dudkov commented on IGNITE-4205:
---
My last commit added this flag and checked read back works.
I'll check same issuei for CacheAbstractJdbcStore and will add separate ticket
if it is same there.
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Konstantin Dudkov
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16012039#comment-16012039
]
Valentin Kulichenko commented on IGNITE-4205:
-
[~kdudkov], can you please also check if the same issue exists in JDBC store
({{CacheAbstractJdbcStore}})? If yes, it needs to be fixed in the same way.
As for your last comment, {{BinaryConfiguration#compactFooter}} should be set
to {{false}} in this scenario. Please try and make sure it works.
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Konstantin Dudkov
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16006142#comment-16006142
]
Konstantin Dudkov commented on IGNITE-4205:
---
The weird moment: we can't get object from cache after loadAll(), because we
can't deserealize it due to absence of metadata in new ignite instance. But we
can get binary representation of it using .withKeepBinary().get()
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Konstantin Dudkov
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16005039#comment-16005039
]
Konstantin Dudkov commented on IGNITE-4205:
---
I created new [GitHub pr|https://github.com/apache/ignite/pull/1925], with
changes and a test for the scenario described in the ticket
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Konstantin Dudkov
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16004633#comment-16004633
]
Konstantin Dudkov commented on IGNITE-4205:
---
Due to no activity I'll try to complete ticket.
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Igor Rudyak
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.15#6346)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15750005#comment-15750005
]
Valentin Kulichenko commented on IGNITE-4205:
-
[~irudyak], the idea behind this is not to deserialize them on server side. One
of the main features of binary format is that it allows not to deploy classes
on server and dynamically change the schema. If you deserialize before calling
the store, this is not possible. But weird thing is that this is controlled by
{{cacheStoreFactory}} configuration flag, which it's actually set to true in
your case, so the {{CacheStore}} implementation should get binary objects. Not
sure why this doesn't work for you...
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Igor Rudyak
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15738308#comment-15738308
]
Igor Rudyak commented on IGNITE-4205:
-
Valentin, could you please clarify this "When an object is saved, it's passed
to the store as an instance of BinaryObject"?
I did this:
IgniteCache myCache = ignite.cache("mycache").withKeepBinary();
myCache.put(1L, new MyObject());
But on CacheStore side, inside write(final Cache.Entry entry) method I still have MyObject instance inside the entry object.
Should I construct BinaryObject manually? Looks like I can do this using
BinaryObjectBuilder, but the idea itself looks rather awkwardly. If I am
correct, the main idea of binary objects is to use them for read only
operations on different clients (Java, .Net and etc.) which provides kind of
"platform independent" serialization. While for write operations I can use my
custom Java class instances and they will be automatically converted to
BinaryObjects right?
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Igor Rudyak
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15724582#comment-15724582
]
Igor Rudyak commented on IGNITE-4205:
-
Valentin I can easily do this, but it looks like IgniteThread implementation
doesn't have anything special related to marchalling/unmarshalling - just only
a number of getters and setters. Thus it looks like it shouldn't work. Am I
wrong?
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Igor Rudyak
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
[jira] [Commented] (IGNITE-4205) CassandraCacheStore should start IgniteThread threads in loadCache() method
[
https://issues.apache.org/jira/browse/IGNITE-4205?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=15703685#comment-15703685
]
Valentin Kulichenko commented on IGNITE-4205:
-
[~irudyak], the change looks good to me, but it seems to be not tested. Can you
create a test for the scenario I described in the ticket? We need to make sure
that the solution is actually working.
We also need to make similar change in {{CacheAbstractJdbcStore}}. Can you do
this as well? Or you prefer to create a separate ticket for this?
> CassandraCacheStore should start IgniteThread threads in loadCache() method
> ---
>
> Key: IGNITE-4205
> URL: https://issues.apache.org/jira/browse/IGNITE-4205
> Project: Ignite
> Issue Type: Bug
> Components: cache
>Affects Versions: 1.7
>Reporter: Valentin Kulichenko
>Assignee: Igor Rudyak
>
> {{CassandraCacheStore.loadCache()}} method starts a generic thread pool for
> parallel data load. Threads in this thread pool can't deserialize Ignite
> internal objects (e.g. {{IgniteKernal}}) which can cause unexpected behavior.
> Here is one of the scenarios:
> * There is column in Cassandra which stores an object as BLOB using
> {{JavaSerializer}}.
> * {{CacheConfiguration.storeKeepBinary}} is {{true}}.
> * When an object is saved, it's passed to the store as an instance of
> {{BinaryObject}} which is converted to a byte array and saved in Cassandra.
> * When the same object is loaded in {{loadCache}}, the store takes the byte
> array and tries to convert it to {{BinaryObject}}. But it can't because this
> implies calling {{IgnitionEx.localIgnite()}} from non-Ignite thread.
> To fix this we need to provide a thread factory that will create instances of
> {{IgniteThread}} and use it in the pool that loads the data.
> Most likely the same issue exists in {{CacheAbstractJdbcStore}}.
> And in general, any threads created by Ignite internals should be
> {{IgniteThread}}-s. This should be revisited.
--
This message was sent by Atlassian JIRA
(v6.3.4#6332)
