[JBoss JIRA] (JGRP-2288) S3_PING: Under certain conditions, subclusters fail to merge after network partition
by Bela Ban (Jira)
[ https://issues.jboss.org/browse/JGRP-2288?page=com.atlassian.jira.plugin.... ]
Bela Ban updated JGRP-2288:
---------------------------
Fix Version/s: 4.0.17
(was: 4.0.16)
> S3_PING: Under certain conditions, subclusters fail to merge after network partition
> ------------------------------------------------------------------------------------
>
> Key: JGRP-2288
> URL: https://issues.jboss.org/browse/JGRP-2288
> Project: JGroups
> Issue Type: Bug
> Affects Versions: 3.6.15
> Reporter: Nick Sawadsky
> Assignee: Bela Ban
> Priority: Major
> Fix For: 4.0.17
>
>
> Repro steps:
> 1. Set up a cluster of four nodes, two on one machine (Host 1) and two on another (Host 2). Let's call the nodes A, B, C, and D.
> 2. Configure all 4 nodes with S3_PING as the discovery mechanism. Set remove_all_files_on_view_change to true.
> 3. Start up nodes in the order A, B, C, D.
> 4. In the S3 bucket, there should be a single file with all four nodes listed. Node A should be flagged as the coordinator. Ensure that the UUID for node B is larger than the UUID for node C, when compared as two's complement integers. If this is not the case, shut down all nodes and restart in order. Repeat until the desired relationship is achieved. Note that with two's complement, a UUID having a first hex digit of 8 or higher is treated as negative for comparison purposes. So, for example, a UUID starting with 'a' is less than a UUID starting with 'b' which is less than a UUID starting with '1'.
> 5. On Host 1, use iptables to block all traffic going to and coming from Host 2.
> sudo iptables -A INPUT -s <Host 2 IP addr> -j DROP
> sudo iptables -A OUTPUT -d <Host 2 IP addr> -j DROP
> 6. Allow a few minutes for the nodes to detect the network partition. Eventually you should see two files in the S3 bucket.
> 7. Using Ctrl-C, stop node A.
> 8. You should soon find only a single file in the bucket, containing a single entry for node B. This is a result of the remove_all_files_on_view_change setting on S3_PING, which we set to true to avoid accumulation of old files in the bucket.
> 9. Resolve the network partition:
> sudo iptables -F OUTPUT
> sudo iptables -F INPUT
> 10. You will find that, even after many minutes, the subclusters are not merged.
> I believe the reason why the subclusters are never merged is as follows:
> - MERGE3 on nodes B, C and D uses S3_PING to find members to send INFO messages to. Each one finds only node B in the discovery file. As a result, only node B's view consistency checker has anything to work with.
> - On node B, the consistency checker can see that there are two coordinators, B and C. However, node C has a lower UUID, so node B defers to it to perform the merge. Node C never performs the merge because, as mentioned above, it is not receiving any INFO messages.
> I this this problem would affect FILE_PING as well, and other protocols derived from FILE_PING. Looking at the latest 4.x code, it appears the problem still exists there.
> I think the crux of the issue is that the coordinator on Host 2 (node C) does not re-create its discovery file after it is deleted by node B. Would it be reasonable for FILE_PING.findMembers() to create the discovery file if the node is a coordinator and the file doesn't exist?
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 6 months
[JBoss JIRA] (JGRP-2299) LockService does not work correctly if unlock/lock is called in immediate succession
by Bela Ban (Jira)
[ https://issues.jboss.org/browse/JGRP-2299?page=com.atlassian.jira.plugin.... ]
Bela Ban updated JGRP-2299:
---------------------------
Fix Version/s: 4.0.17
(was: 4.0.16)
> LockService does not work correctly if unlock/lock is called in immediate succession
> ------------------------------------------------------------------------------------
>
> Key: JGRP-2299
> URL: https://issues.jboss.org/browse/JGRP-2299
> Project: JGroups
> Issue Type: Bug
> Affects Versions: 4.0.15
> Environment: Windows 10 Oracle JDK 1.8 131
> AIX IBM Java 8
> Reporter: Mirko Streckenbach
> Assignee: Bela Ban
> Priority: Major
> Fix For: 4.0.17
>
> Attachments: JGroupsExample.java, udp+lock.xml
>
>
> In our application we have encountered occasional cases of LockService allowing 2 processes to hold the same lock at the same time. I could reproduce this with a simple program (see atttachment) and it happens if for a lock "unlock" is called and immediately afterwards "lock". If there is a small delay (e.g. 1 second) between the two operations everything works as expected.
> This can be produced with the attached program. The program does lock/unlock/lock on a lock and then tries to lock the same lock from a different JChannel and is awarded the lock. If you place a small sleep() after the unlock, everything works as expected and the parallel lock is not awarded.
> If you turn on debugging you'll see no output between unlock and lock, so it looks to me like the lock is awarded without passing GRANT_LOCK messages to the stack. Using a conditional break point you can see that ClientLock.acquired is still true even after the unlock().
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 6 months
[JBoss JIRA] (DROOLS-3242) [Scenario Simulation] All grid cell editing should respond to single click
by Jozef Marko (Jira)
[ https://issues.jboss.org/browse/DROOLS-3242?page=com.atlassian.jira.plugi... ]
Jozef Marko updated DROOLS-3242:
--------------------------------
Labels: ScenarioSimulation UX UXTeam (was: UX UXTeam drools-tools)
> [Scenario Simulation] All grid cell editing should respond to single click
> ---------------------------------------------------------------------------
>
> Key: DROOLS-3242
> URL: https://issues.jboss.org/browse/DROOLS-3242
> Project: Drools
> Issue Type: Feature Request
> Components: DMN Editor
> Affects Versions: 7.10.0.Final
> Reporter: Ivo Bek
> Assignee: Daniele Zonca
> Priority: Major
> Labels: ScenarioSimulation, UX, UXTeam
>
> Following from a discussion about https://issues.jboss.org/browse/DROOLS-2874 it was agreed that editing cells (header or body) in the grids should respond to single-click and not double-click.
> h2. Manual Acceptance Test
> - Not possible edit multiple cells by hold CTRL and click on multiple cells
> - Click column/row leading cell discard edit dialog
> - Edit can be discarded by escape
> - Edit can be discarded by click to canvas
> - Invoke edit of cell
> - Save and reopen
> - Undo redo of editation
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 6 months
[JBoss JIRA] (JGRP-2312) LazyThreadFactory can keep threads instances alive for a long period
by Dan Berindei (Jira)
[ https://issues.jboss.org/browse/JGRP-2312?page=com.atlassian.jira.plugin.... ]
Dan Berindei commented on JGRP-2312:
------------------------------------
[~belaban] I understand that the cluster name and address may not be known during {{TP.init()}}, but couldn't you create the thread pools only after you know the cluster name and address? To me, the lazy renaming just muddies the initialization story, so it's not clear exactly when the cluster name and address are available.
If you really can't create the thread pool after you know both, {{LazyThreadFactory}} could keep the list until {{TP}} finds out the cluster name and address, but stop keeping track of created threads once the cluster name and address are set.
> LazyThreadFactory can keep threads instances alive for a long period
> --------------------------------------------------------------------
>
> Key: JGRP-2312
> URL: https://issues.jboss.org/browse/JGRP-2312
> Project: JGroups
> Issue Type: Bug
> Affects Versions: 4.0.15
> Reporter: William Burns
> Assignee: Bela Ban
> Priority: Major
> Fix For: 4.0.16
>
>
> The LazyThreadFactory keeps all Thread objects in a ConcurrentLinkedQueue wrapped by a WeakReference. This means that once a thread terminates, its instance along with all native memory required for it can linger until the GC eventually reclaims it. Normally this is not an issue when the JVM heap is being recycled often, but in cases where you have low heap requirement operations (ie. off heap data container) this can cause these objects to pile up and eventually exhaust native memory.
> This queue is also a very slow JVM heap leak as threads are tossed out, since the WeakReference and Queue Node objects are never reclaimed unless the transport is stopped.
> The best way to fix this would be to plug into when the thread is set to TERMINATED state and to remove these nodes.
> Also a workaround is to increase the core thread count and increase the keepalive timeout so that threads are not destroyed and created nearly as often.
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 6 months
[JBoss JIRA] (DROOLS-3061) [DMN Designer] Automatic Layout Feature
by Jozef Marko (Jira)
[ https://issues.jboss.org/browse/DROOLS-3061?page=com.atlassian.jira.plugi... ]
Jozef Marko reassigned DROOLS-3061:
-----------------------------------
Assignee: Jozef Marko (was: Daniel José dos Santos)
> [DMN Designer] Automatic Layout Feature
> ---------------------------------------
>
> Key: DROOLS-3061
> URL: https://issues.jboss.org/browse/DROOLS-3061
> Project: Drools
> Issue Type: Epic
> Components: DMN Editor
> Reporter: Jozef Marko
> Assignee: Jozef Marko
> Priority: Major
> Labels: drools-tools
>
> DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
> User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
> The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
> *Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
> *Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
> This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
> *Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
> *Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
> *Architecture*
> From the design of view the goals are:
> * +Layout Public interface & DMN implementation+
> ** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
> ** Build a well defined layout API (shared) on some _api_ module
> ** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
> ** Any other common or base classes can be placed inside the _commons_ module
> * +Designer integration+
> ** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
> ** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
> ** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 6 months
[JBoss JIRA] (DROOLS-3061) [DMN Designer] Automatic Layout Feature
by Jozef Marko (Jira)
[ https://issues.jboss.org/browse/DROOLS-3061?page=com.atlassian.jira.plugi... ]
Jozef Marko reassigned DROOLS-3061:
-----------------------------------
Assignee: Daniel José dos Santos (was: Jozef Marko)
> [DMN Designer] Automatic Layout Feature
> ---------------------------------------
>
> Key: DROOLS-3061
> URL: https://issues.jboss.org/browse/DROOLS-3061
> Project: Drools
> Issue Type: Epic
> Components: DMN Editor
> Reporter: Jozef Marko
> Assignee: Daniel José dos Santos
> Priority: Major
> Labels: drools-tools
>
> DMN Designer should *autolayout* new imported DMN models. The *autolayout* should position DRG diagram nodes into horizontal layers to minimize crossing of connectors with respect of *Top-Down* importance. It means if nodes *Layer B* are inputs for nodes in *Layer A* then the *Layer B* will be below *Layer A*. The *autolayout* should also try to minimize scrolling needed to see whole DRG diagram.
> User should also have possibility to invoke *autolayout* feature any time during designing the diagram. In this case the action should be undoable with the *Undo* toolbar button.
> The approach used to achieve this is the Sugiyama Method, which is done in 4 steps. Each step have its own set of algorithms. For each step, we selected one of the available algorithms to implement, based on our current needs and time to develop:
> *Step 1 - Cycle breaking:* We break cycles in diagram by reversing some edges (they are de-reversed in the end). This step are required because we need ending points in step 2 while sweeping through graph;
> *Step 2 - Layering:* We sweep through graph (diagram) and put each node (vertex) in a layer, based on it's distance from others node. For edges that crosses multiple layers, we create virtual vertices connecting those. They are removed at the end.
> This approach usually puts the start nodes at the top and the deepest nodes at the end. In the current implementation we're using Longest Path algorithm. A better approach can be developed in future using Network Simplex;
> *Step 3 - Node Ordering:* We order each node (vertex) inside its layers in order to reduce crossing, using median. Another approach that can be used is barycenter.
> *Step 4 - Node Positioning:* We de-reverse nodes reversed in step 1 and remove virtual nodes reconnecting the concrete nodes. Then we calculate the position of each node. This step can be divided in two steps: one for horizontal position and other for vertical for better positioning. Currently we're using a simple approach: every block of nodes inside the layers is centered and the distance between layers is the same. So it will produce results like the attachment "Automatic Layout Demo".
> *Architecture*
> From the design of view the goals are:
> * +Layout Public interface & DMN implementation+
> ** The goal for this API is to provide the layout declaration data for an input Graph (DMN, BPMN, etc) instance. It will NOT mutate the graph structure and/or data at all. This way it will provide methods for calculating the candidate locations for the graph elements. even could be the case the elements must be resized as well, and it returns on some result data object that specifies the necessary updates to be done on the elements. So the resulting layout data will be consumed by another component that will use the _command API_ in order to perform the necessary updates (location, size) for the graph' elements.
> ** Build a well defined layout API (shared) on some _api_ module
> ** Build the requested layout implementation specific for DMN inside some DMN shared module (considering the implementation is shared between client and server)
> ** Any other common or base classes can be placed inside the _commons_ module
> * +Designer integration+
> ** Once having the layout API and implementations, next step is to consume this API in order to obtain the layout data and use it to mutate the graph structure. So we need some kind of component for this, for example we can name it as _LayoutExecutor_.
> ** Create some default layout executor which will consume the layout API and use the command API to perform the updates on the model (graph) via "commands", this way we can undo/redo all the operations on the designer
> ** [Optional] This designer integration can be done as generic, and so reuse it for other domains like BPMN, or just specific for DMN
--
This message was sent by Atlassian Jira
(v7.12.1#712002)
7 years, 6 months