[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[
https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16326671#comment-16326671
]
Danny Lane commented on NIFIREG-77:
---
I've added a WIP commit here is anyone would like to offer feedback before I
submit a PR?
https://github.com/dannylane/nifi-registry/commit/eeed846167dc90d983ea1d37d4149980b3057be2
I tried to go with the API returning the existing diff classes but each
{{FlowDifference}} contains references to before/after versions of the
components and they got serialized in the API response which I though was a bit
much.
I added a couple of classes to the model module to act as the response form the
API (they are essentially {{Dto}} s but I didn't use that naming convention as
I didn't see it used in the registry project).
The behavior is very similar to how NiFi gathers it's changes for the 'Show
Local Changes' functionality at the moment.
Happy to make changes if this is way off base...
> Allow a user to see the changes created by the currently loaded version
> ---
>
> Key: NIFIREG-77
> URL: https://issues.apache.org/jira/browse/NIFIREG-77
> Project: NiFi Registry
> Issue Type: Improvement
>Affects Versions: 0.1.0
>Reporter: Joseph Percivall
>Priority: Critical
> Attachments: Suggestion for diff UX.png
>
>
> As a user, I would like to see the changes that are included in a particular
> version. More specifically, if I'm on an old version and I upgrade to a
> version written by someone else, I have no way to know what changes occurred
> during that version upgrade.
> A simple solution would be to utilize the same logic which displays the
> current differences between local and stored in the registry and use that to
> show the differences between the current version N and version N-1. The user
> could then change between versions to see the changes that happened as part
> of that version.
> An even better solution (from a DFM perspective) would be to be able to see
> the changes within any version (not just the most recent). That way a DFM
> wouldn't have to stop the flow for an extended period of time to view the
> changes/differences in different versions but I think that'd be more work.
--
This message was sent by Atlassian JIRA
(v7.6.3#76005)
[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[ https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16322709#comment-16322709 ] Rob Moran commented on NIFIREG-77: -- I think it makes sense to enable multiple selections the same way that it is done in the users or buckets table of the admin section with right-aligned checkboxes and an action (_Compare versions_) available from the Actions button menu. This approach will scale nicely as more functionality that can be performed on a resource is introduced. [~scottyaslan] I am wondering how interaction would work here. I'm thinking each Change Log "row" will need two, more carefully defined areas a user can click on: 1) the current area that opens/closes details, and 2) a new area containing a checkbox. Clicking the checkbox area would apply similar styling as a selected table row -- thoughts? > Allow a user to see the changes created by the currently loaded version > --- > > Key: NIFIREG-77 > URL: https://issues.apache.org/jira/browse/NIFIREG-77 > Project: NiFi Registry > Issue Type: Improvement >Affects Versions: 0.1.0 >Reporter: Joseph Percivall >Priority: Critical > Attachments: Suggestion for diff UX.png > > > As a user, I would like to see the changes that are included in a particular > version. More specifically, if I'm on an old version and I upgrade to a > version written by someone else, I have no way to know what changes occurred > during that version upgrade. > A simple solution would be to utilize the same logic which displays the > current differences between local and stored in the registry and use that to > show the differences between the current version N and version N-1. The user > could then change between versions to see the changes that happened as part > of that version. > An even better solution (from a DFM perspective) would be to be able to see > the changes within any version (not just the most recent). That way a DFM > wouldn't have to stop the flow for an extended period of time to view the > changes/differences in different versions but I think that'd be more work. -- This message was sent by Atlassian JIRA (v6.4.14#64029)
[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[ https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16321400#comment-16321400 ] Danny Lane commented on NIFIREG-77: --- I've added the two sub tasks as per [~bbende]'s suggestion. Please update if I've missed something or theres a format I should have used. I've started work on the API endpoint, I'll link to a WIP branch in a couple of days if anyone wants to offer suggestions. > Allow a user to see the changes created by the currently loaded version > --- > > Key: NIFIREG-77 > URL: https://issues.apache.org/jira/browse/NIFIREG-77 > Project: NiFi Registry > Issue Type: Improvement >Affects Versions: 0.1.0 >Reporter: Joseph Percivall >Priority: Critical > Attachments: Suggestion for diff UX.png > > > As a user, I would like to see the changes that are included in a particular > version. More specifically, if I'm on an old version and I upgrade to a > version written by someone else, I have no way to know what changes occurred > during that version upgrade. > A simple solution would be to utilize the same logic which displays the > current differences between local and stored in the registry and use that to > show the differences between the current version N and version N-1. The user > could then change between versions to see the changes that happened as part > of that version. > An even better solution (from a DFM perspective) would be to be able to see > the changes within any version (not just the most recent). That way a DFM > wouldn't have to stop the flow for an extended period of time to view the > changes/differences in different versions but I think that'd be more work. -- This message was sent by Atlassian JIRA (v6.4.14#64029)
[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[
https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16320464#comment-16320464
]
Bryan Bende commented on NIFIREG-77:
[~DannyLane] that is a good point about introducing a new dependency, we
definitely want to be very careful about what gets introduced to the client
module so that people using it aren't forced to bring in all kinds of stuff.
In this case, since {{nifi-registry-flow-diff}} only has a single dependency
which is {{nifi-registry-data-model}}, I would be ok with the client also
depending on flow diff, and we know NiFi already depends on flow diff so it
would be ok from that perspective.
I'm not opposed to your original idea though (adding new data model classes and
keeping the flow diff stuff hidden away), I was just trying to think of how to
make it easiest to integrate on the NiFi side.
In either case, I would do what you suggested about putting the core logic of
the comparison in {{RegistryService}}, and from there its just a matter of
deciding if that should return stuff from flow diff, or some new objects from
data model.
> Allow a user to see the changes created by the currently loaded version
> ---
>
> Key: NIFIREG-77
> URL: https://issues.apache.org/jira/browse/NIFIREG-77
> Project: NiFi Registry
> Issue Type: Improvement
>Affects Versions: 0.1.0
>Reporter: Joseph Percivall
>Priority: Critical
> Attachments: Suggestion for diff UX.png
>
>
> As a user, I would like to see the changes that are included in a particular
> version. More specifically, if I'm on an old version and I upgrade to a
> version written by someone else, I have no way to know what changes occurred
> during that version upgrade.
> A simple solution would be to utilize the same logic which displays the
> current differences between local and stored in the registry and use that to
> show the differences between the current version N and version N-1. The user
> could then change between versions to see the changes that happened as part
> of that version.
> An even better solution (from a DFM perspective) would be to be able to see
> the changes within any version (not just the most recent). That way a DFM
> wouldn't have to stop the flow for an extended period of time to view the
> changes/differences in different versions but I think that'd be more work.
--
This message was sent by Atlassian JIRA
(v6.4.14#64029)
[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[
https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16319969#comment-16319969
]
Danny Lane commented on NIFIREG-77:
---
Thanks [~bbende], that's helpful.
I had seen the NiFi code around the creating the FlowComparator and mapping to
the DTOs but like you said, i was still trying to work out what the response
from the new end-point should be.
At the moment it looks like most that I can see (all?) of the responses from
the {{nifi-registry-web-api}} and {{nifi-registry-client}} are types from
{{nifi-registry-data-model}}, {{FlowDifference}} isn't in the model module. Is
there any issue with this? and adding {{nifi-registry-flow-diff}} as a
dependency to both the api and client? This may be fine, I just wanted to
confirm I wasn't breaking the pattern.
What I was thinking about before I read your comment above was to put the
FlowComparator logic in {{org.apache.nifi.registry.service.RegistryService}}
and map to/return new types in the data-model module. so the client & api
wouldn't need new references to the diff module. This might not even be an
issue?
I'm happy enough to go either route, let me know what you prefer and I'll start
putting something together.
> Allow a user to see the changes created by the currently loaded version
> ---
>
> Key: NIFIREG-77
> URL: https://issues.apache.org/jira/browse/NIFIREG-77
> Project: NiFi Registry
> Issue Type: Improvement
>Affects Versions: 0.1.0
>Reporter: Joseph Percivall
>Priority: Critical
> Attachments: Suggestion for diff UX.png
>
>
> As a user, I would like to see the changes that are included in a particular
> version. More specifically, if I'm on an old version and I upgrade to a
> version written by someone else, I have no way to know what changes occurred
> during that version upgrade.
> A simple solution would be to utilize the same logic which displays the
> current differences between local and stored in the registry and use that to
> show the differences between the current version N and version N-1. The user
> could then change between versions to see the changes that happened as part
> of that version.
> An even better solution (from a DFM perspective) would be to be able to see
> the changes within any version (not just the most recent). That way a DFM
> wouldn't have to stop the flow for an extended period of time to view the
> changes/differences in different versions but I think that'd be more work.
--
This message was sent by Atlassian JIRA
(v6.4.14#64029)
[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[
https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16318950#comment-16318950
]
Bryan Bende commented on NIFIREG-77:
[~DannyLane] thanks for jumping in here!
I think that REST end-point makes a lot of sense, I was thinking of something
similar myself. The only part we need to think about is what to return from
that end-point...
Currently NiFi makes a FlowComparator and calls compare() to get a
FlowComparison which has FlowDifference objects. All of these are already part
of the nifi-registry-flow-diff-module and NiFI is using it as a library, rather
than a remote call.
NiFi then converts those objects into it's DTOs which are something like...
FlowComparisonEntity -> set of ComponentDifferenceDTOs -> set of DifferenceDTOs.
I think it might make sense to return an entity that wraps a set/list of
FlowDifference objects, and this way NiFi already has the code to convert those
difference objects into it's appropriate DTOs.
If we did it this way we would add something to the NiFi Registry client like:
{code}
FlowComparisonEntity getDifferences(String bucketId, String flowId, int
firstVersion, int secondVersion)
{code}
Where FlowComparisonEntity has Set getDifferences()
What do you think about that?
Maybe we can create two sub-tasks for this, one of the REST API and for the UI,
this way we can work this in different chunks.
For the UI we need some feedback from Rob and Scott, but I think the REST API
can be fairly well-defined and worked.
> Allow a user to see the changes created by the currently loaded version
> ---
>
> Key: NIFIREG-77
> URL: https://issues.apache.org/jira/browse/NIFIREG-77
> Project: NiFi Registry
> Issue Type: Improvement
>Affects Versions: 0.1.0
>Reporter: Joseph Percivall
>Priority: Critical
> Attachments: Suggestion for diff UX.png
>
>
> As a user, I would like to see the changes that are included in a particular
> version. More specifically, if I'm on an old version and I upgrade to a
> version written by someone else, I have no way to know what changes occurred
> during that version upgrade.
> A simple solution would be to utilize the same logic which displays the
> current differences between local and stored in the registry and use that to
> show the differences between the current version N and version N-1. The user
> could then change between versions to see the changes that happened as part
> of that version.
> An even better solution (from a DFM perspective) would be to be able to see
> the changes within any version (not just the most recent). That way a DFM
> wouldn't have to stop the flow for an extended period of time to view the
> changes/differences in different versions but I think that'd be more work.
--
This message was sent by Atlassian JIRA
(v6.4.14#64029)
[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[
https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16316920#comment-16316920
]
Danny Lane commented on NIFIREG-77:
---
I've spent some time looking at the code in NiFi that is used to detect the
local changes to a flow.
I was thinking about an endpoint in NiFi Registry in the BucketFlowResource,
something along the lines of
{code:java}
/buckets/{bucketId}/flows/{flowId}/diff/{versionA}/{versionB}
{code}
(versionB could be optional and default to N-1 if omitted)
I've attached a mock of one possible location for invoking the diff from the
registry UI. Clicking the 'View Changes' link could display a modal similar to
the current 'Show Local Changes' model in NiFi, or it could display the grid
inline. There a probably a number of options for the UX here.
The API response for the {{local-modifications}} endpoint in NiFi seems like a
good way of returning the diff so I think it might be a good idea to try and
keep the registry response to a similar structure.
Once the diff API is in place it would be available for NiFi to invoke and
display a similar screen for changes on its side.
!Suggestion for diff UX.png!
> Allow a user to see the changes created by the currently loaded version
> ---
>
> Key: NIFIREG-77
> URL: https://issues.apache.org/jira/browse/NIFIREG-77
> Project: NiFi Registry
> Issue Type: Improvement
>Affects Versions: 0.1.0
>Reporter: Joseph Percivall
>Priority: Critical
> Attachments: Suggestion for diff UX.png
>
>
> As a user, I would like to see the changes that are included in a particular
> version. More specifically, if I'm on an old version and I upgrade to a
> version written by someone else, I have no way to know what changes occurred
> during that version upgrade.
> A simple solution would be to utilize the same logic which displays the
> current differences between local and stored in the registry and use that to
> show the differences between the current version N and version N-1. The user
> could then change between versions to see the changes that happened as part
> of that version.
> An even better solution (from a DFM perspective) would be to be able to see
> the changes within any version (not just the most recent). That way a DFM
> wouldn't have to stop the flow for an extended period of time to view the
> changes/differences in different versions but I think that'd be more work.
--
This message was sent by Atlassian JIRA
(v6.4.14#64029)
[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[ https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16316888#comment-16316888 ] Rob Moran commented on NIFIREG-77: -- [~bbende] discussion has been looking at it from both Registry and NiFi. I agree we should capture NiFi functionality in a separate NIFI JIRA. I think a good place to start is from the Registry side so a user could choose any two versions of a flow (or of any resource type that the registry tracks) and compare. As you mention, NiFi could potentially leverage that work to allow relevant comparisons to take from its UI when a user performs version control related actions (like an upgrade). > Allow a user to see the changes created by the currently loaded version > --- > > Key: NIFIREG-77 > URL: https://issues.apache.org/jira/browse/NIFIREG-77 > Project: NiFi Registry > Issue Type: Improvement >Affects Versions: 0.1.0 >Reporter: Joseph Percivall >Priority: Critical > > As a user, I would like to see the changes that are included in a particular > version. More specifically, if I'm on an old version and I upgrade to a > version written by someone else, I have no way to know what changes occurred > during that version upgrade. > A simple solution would be to utilize the same logic which displays the > current differences between local and stored in the registry and use that to > show the differences between the current version N and version N-1. The user > could then change between versions to see the changes that happened as part > of that version. > An even better solution (from a DFM perspective) would be to be able to see > the changes within any version (not just the most recent). That way a DFM > wouldn't have to stop the flow for an extended period of time to view the > changes/differences in different versions but I think that'd be more work. -- This message was sent by Atlassian JIRA (v6.4.14#64029)
[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[ https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16316807#comment-16316807 ] Joseph Percivall commented on NIFIREG-77: - [~bbende] when I originally created the ticket I was thinking of the view within NiFi but given this is the Registry Jira, I agree with you that it should focus on the Registry side and we'd create a ticket for the NiFi side. Partially I didn't want to create a bunch of tickets in the NiFi Jira at the time because the core PR wasn't merged yet. Now that's merged we can go that route though. > Allow a user to see the changes created by the currently loaded version > --- > > Key: NIFIREG-77 > URL: https://issues.apache.org/jira/browse/NIFIREG-77 > Project: NiFi Registry > Issue Type: Improvement >Affects Versions: 0.1.0 >Reporter: Joseph Percivall >Priority: Critical > > As a user, I would like to see the changes that are included in a particular > version. More specifically, if I'm on an old version and I upgrade to a > version written by someone else, I have no way to know what changes occurred > during that version upgrade. > A simple solution would be to utilize the same logic which displays the > current differences between local and stored in the registry and use that to > show the differences between the current version N and version N-1. The user > could then change between versions to see the changes that happened as part > of that version. > An even better solution (from a DFM perspective) would be to be able to see > the changes within any version (not just the most recent). That way a DFM > wouldn't have to stop the flow for an extended period of time to view the > changes/differences in different versions but I think that'd be more work. -- This message was sent by Atlassian JIRA (v6.4.14#64029)
[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[ https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16316783#comment-16316783 ] Bryan Bende commented on NIFIREG-77: [~JPercivall] [~rmoran] Is this JIRA primarily talking about the NiFi UI, the registry UI, or both? I'd like to be able to select two versions in the registry UI and compare them, or possibly compare a version with previous since I would usually be interested in changes between two versions. I also agree that we should have a way for the NiFi side to show differences between the current version and whatever is available for upgrade, however that should probably be a JIRA on the NiFi side which would potentially call/use something developed in this JIRA. > Allow a user to see the changes created by the currently loaded version > --- > > Key: NIFIREG-77 > URL: https://issues.apache.org/jira/browse/NIFIREG-77 > Project: NiFi Registry > Issue Type: Improvement >Affects Versions: 0.1.0 >Reporter: Joseph Percivall >Priority: Critical > > As a user, I would like to see the changes that are included in a particular > version. More specifically, if I'm on an old version and I upgrade to a > version written by someone else, I have no way to know what changes occurred > during that version upgrade. > A simple solution would be to utilize the same logic which displays the > current differences between local and stored in the registry and use that to > show the differences between the current version N and version N-1. The user > could then change between versions to see the changes that happened as part > of that version. > An even better solution (from a DFM perspective) would be to be able to see > the changes within any version (not just the most recent). That way a DFM > wouldn't have to stop the flow for an extended period of time to view the > changes/differences in different versions but I think that'd be more work. -- This message was sent by Atlassian JIRA (v6.4.14#64029)
[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[ https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16316392#comment-16316392 ] Rob Moran commented on NIFIREG-77: -- [~JPercivall] I see your points and it makes sense. I think the two actions (show local changes & compare versions) will result in similar experiences – which is what led to my thought about coming together under one – but you're right, presenting them as two options would be more clear. They each have a distinct purpose when operating inside NiFi. The _compare versions_ language can still be used across both the NiFi and Registry UIs. > Allow a user to see the changes created by the currently loaded version > --- > > Key: NIFIREG-77 > URL: https://issues.apache.org/jira/browse/NIFIREG-77 > Project: NiFi Registry > Issue Type: Improvement >Affects Versions: 0.1.0 >Reporter: Joseph Percivall >Priority: Critical > > As a user, I would like to see the changes that are included in a particular > version. More specifically, if I'm on an old version and I upgrade to a > version written by someone else, I have no way to know what changes occurred > during that version upgrade. > A simple solution would be to utilize the same logic which displays the > current differences between local and stored in the registry and use that to > show the differences between the current version N and version N-1. The user > could then change between versions to see the changes that happened as part > of that version. > An even better solution (from a DFM perspective) would be to be able to see > the changes within any version (not just the most recent). That way a DFM > wouldn't have to stop the flow for an extended period of time to view the > changes/differences in different versions but I think that'd be more work. -- This message was sent by Atlassian JIRA (v6.4.14#64029)
[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[ https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16313361#comment-16313361 ] Joseph Percivall commented on NIFIREG-77: - Hey [~rmoran], Totally agree with the need for a "diff" feature. I see the end goal of the features and UX of versioned flows as very similar to the UX of git. Thinking along the lines of git, the most used features in git are to see the locally uncommitted changes and see what changed in the last X commits (i.e., checking a PR). That said, while they're similar, the mentality of each is quite different and I don't think they should always be treated as such (combining them into one "compare versions" action). The first is checking things that have yet to be saved and can still be changed. The other is verifying changes that have already been saved. So I don't think having a shortcut for "show local changes" and the ability to "compare versions" (including the local one) are mutually exclusive. I understand wanting consistency, but I'm not convinced that changing "show local changes" to only be a part of the "compare versions" would be a better UX. > Allow a user to see the changes created by the currently loaded version > --- > > Key: NIFIREG-77 > URL: https://issues.apache.org/jira/browse/NIFIREG-77 > Project: NiFi Registry > Issue Type: Improvement >Affects Versions: 0.1.0 >Reporter: Joseph Percivall >Priority: Critical > > As a user, I would like to see the changes that are included in a particular > version. More specifically, if I'm on an old version and I upgrade to a > version written by someone else, I have no way to know what changes occurred > during that version upgrade. > A simple solution would be to utilize the same logic which displays the > current differences between local and stored in the registry and use that to > show the differences between the current version N and version N-1. The user > could then change between versions to see the changes that happened as part > of that version. > An even better solution (from a DFM perspective) would be to be able to see > the changes within any version (not just the most recent). That way a DFM > wouldn't have to stop the flow for an extended period of time to view the > changes/differences in different versions but I think that'd be more work. -- This message was sent by Atlassian JIRA (v6.4.14#64029)
[jira] [Commented] (NIFIREG-77) Allow a user to see the changes created by the currently loaded version
[ https://issues.apache.org/jira/browse/NIFIREG-77?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanel=16313321#comment-16313321 ] Rob Moran commented on NIFIREG-77: -- Described as the "even better solution" in the issue description, I think what is ultimately needed is a _diff_ feature where a user – from the Registry UI – can view a side-by-side comparison of any two versions of a resource. >From the NiFi UI side, the diff view can be repurposed to show when a user >chooses the _show local changes_ action, and *optionally* when a user submits >a _change version_ action. I emphasize optionally in case they absolutely know >they want to change versions and don't need to see a diff. Perhaps in the NiFi UI, the _show local changes_ action becomes _compare versions_ which would allow the user to select any two versions (including the local one if it's modified). The action – _compare versions_ – would then be used consistently across the Registry and NiFi UIs and result in the same experience. > Allow a user to see the changes created by the currently loaded version > --- > > Key: NIFIREG-77 > URL: https://issues.apache.org/jira/browse/NIFIREG-77 > Project: NiFi Registry > Issue Type: Improvement >Affects Versions: 0.1.0 >Reporter: Joseph Percivall >Priority: Critical > > As a user, I would like to see the changes that are included in a particular > version. More specifically, if I'm on an old version and I upgrade to a > version written by someone else, I have no way to know what changes occurred > during that version upgrade. > A simple solution would be to utilize the same logic which displays the > current differences between local and stored in the registry and use that to > show the differences between the current version N and version N-1. The user > could then change between versions to see the changes that happened as part > of that version. > An even better solution (from a DFM perspective) would be to be able to see > the changes within any version (not just the most recent). That way a DFM > wouldn't have to stop the flow for an extended period of time to view the > changes/differences in different versions but I think that'd be more work. -- This message was sent by Atlassian JIRA (v6.4.14#64029)
