id
int64 0
5.38k
| issuekey
stringlengths 4
16
| created
stringlengths 19
19
| title
stringlengths 5
252
| description
stringlengths 1
1.39M
| storypoint
float64 0
100
|
|---|---|---|---|---|---|
17 | XD-55 | 05/08/2013 14:18:45 | SI ServiceActivator for an XD Metrics backed Field Value Counter | A Spring Integration based @ServiceActivator that counts the occurrence of field names, from either a tuple data structure or a POJO, using the Spring XD metrics support. | 3 |
18 | XD-56 | 05/08/2013 14:35:44 | Switch to use Lettuce driver for Redis | Replace the use of Jedis with Lettuce as it has higher performance | 2 |
19 | XD-58 | 05/09/2013 14:02:50 | build.gradle doesn't handle a small handful of libraries | Trying to build spring-xd for the first resulted in lots of errors inside STS (I had an empty .m2 repo). | 1 |
20 | XD-59 | 05/10/2013 10:27:04 | Tuple should support storing nested tuples | Nested tuple structures shoudl be supported, getTuple(int index), getTuple(String name) | 1 |
21 | XD-60 | 05/11/2013 10:41:08 | Saving a metric (Counter, Gauge..) with an existing name should throw an exception | The difference between saving a new metric and updating an existing one needs to be defined. Suggest that if we try to save when an existing counter is already in the database to throw exception, such as DataIntegrityViolationException. | 1 |
22 | XD-61 | 05/13/2013 08:47:41 | Create distributable artifact that contains server application and start/stop scripts | The gradle application task should get us most of the way to create a distributable artifact akin to what you see when downloading tomcat/jetty etc. Now there is a launch task task(launch, dependsOn: 'classes', type: JavaExec) { main = 'org.springframework.xd.dirt.stream.StreamServer' classpath = sourceSets.test.runtimeClasspath } The same main should be referenced in the application plugin, a task to create a .zip distributable is needed. Ideally would be nice to 1. download .zip 2. unzip 3. cd spring-xd/bin 4. xdserver start and gracefully shutdown later with 5. xdserver stop I don't know if we can/should bundle redis, I think we should bundle it. The scripts can be for unix/linux and for windows. Discuss a brew based install as well. | 8 |
23 | XD-62 | 05/13/2013 10:02:00 | Use the tuple data structure to process data in a spring batch step | Do not require a POJO in order to do end-to-end processing in a batch step. | 5 |
24 | XD-65 | 05/13/2013 10:26:16 | Gemfire Sink to update a gemfire cache. | Update a gemfire region. | 2 |
25 | XD-67 | 05/14/2013 13:06:23 | Submit a brew-based install for Spring XD | - Host the Spring XD distributable zip somewhere that is accessible by external http request. - Create brew formula for Spring XD install while specifying redis as dependency. - starting up stream server upon successful brew install couple of questions: - should we name the brew task springxd? (name not taken yet) - should we start the stream server as part of the brew install process? - should we specify redis as a recommended dependency? user can pass in 'brew install springxd --without-redis' to skip redis installation. by default, 'brew install springxd' will install redis as well. | 8 |
26 | XD-68 | 05/16/2013 23:46:42 | Export of data from HDFS to a relational database | Based on a single process running a Spring Batch job, support the ETL of data from HDFS to a RDBMS | 8 |
27 | XD-69 | 05/16/2013 23:47:47 | Export of data from HDFS to MongoDB | Based on a single process Spring Batch job, ETL of data from HDFS to MongoDB. | 5 |
28 | XD-71 | 05/17/2013 01:34:15 | Remove UUID from Tuple class or replace with more efficient implementation | The Java UUID class is known not to be the fasted implementation available. See https://github.com/stephenc/eaio-uuid and http://mvnrepository.com/artifact/com.eaio.uuid/uuid for high perf impls. | 1 |
29 | XD-72 | 05/17/2013 09:24:13 | Provide a http source | stream should be able to ingest data from http | 5 |
30 | XD-100 | 05/20/2013 23:28:13 | Rename Tuple class in spring-xd-tuple | The Tuple classes in Reactor follow the more traditional data structure concept of Tuples, an immutable fixed length sequence of values where each value can have different types. They are ordered and can often be access by index. An example in a static language is the Tuple class found in .NET http://msdn.microsoft.com/en-us/library/system.tuple.aspx or in Scala http://www.tutorialspoint.com/scala/scala_tuples.htm Using this standard definition of a Tuple, they do not support named values. There is also a different tuple class instance for each length, e.g. Tuple<T1,T2>, Tuple<T1,T2,T3>. The Tuple class in XD is more like a record or named tuple. Python has a named tuple concept - http://docs.python.org/2/library/collections.html#collections.namedtuple and http://stackoverflow.com/questions/1490413/languages-that-allow-named-tuples shows that other languages use the term 'Record' for a 'named tuple' - Haskell, Standard ML, OCaml, and F#. http://en.wikibooks.org/wiki/F_Sharp_Programming/Tuples_and_Records#Defining_Records So boiling it all down, to avoid conflicts of names, and also to open up the possibility of using Reactor tuples as keys (instead of strings for names), we should change the name to either NamedTuple or Record. ATM, there is no direct relationship between Reactor's Tuple and NamedTuple (such as inheritance) and so probably Record is the way to go. | 2 |
31 | XD-102 | 05/22/2013 23:35:26 | Create XDContainer class to start stream server | Provide optional command line arg to embed the container launcher, aka - xd-admin server. XDContainer.sh --embeddAdmin | 1 |
32 | XD-103 | 05/22/2013 23:37:24 | Create XDAdmin server to start container launcher | This will launch the RedisContainerLauncher, in future will be able to select from a variety of middleware options. | 1 |
33 | XD-104 | 05/23/2013 00:37:43 | Add README to be included in root directory of distribution | should explain basic layout of the distribution | 1 |
34 | XD-105 | 05/23/2013 00:38:49 | Add LICENSE to be included in root directory of distribution | should contain apache licence | 1 |
35 | XD-106 | 05/23/2013 01:22:03 | Container server does not log a message that it has started or stopped successfully | $ ./xd-container processing module 'Module [name=file, type=sink]' from group 'tailtest' with index: 1 processing module 'Module [name=tail, type=source]' from group 'tailtest' with index: 0 Logging of 'processing module' should have log level, time.. | 1 |
36 | XD-108 | 05/23/2013 01:27:49 | Build script should not package 'spring-xd-dirt' scripts | We are packaging separate scripts to start XDAdmin and XDContainer. The Gradle application plugin will generate an unwanted 'spring-xd-dirt' scripts, this should be removed from the bin directory when creating a distribution zip. | 1 |
37 | XD-111 | 05/23/2013 09:39:54 | Create final distribution zip across multiple projects | The final directory structure should look like <install-dir>/xd <install-dir>/redis <install-dir>/gemfire inside the XD directory /xd/bin - which has xd-container and xd-admin scripts /xd/lib inside the gemfire directory /gemfire/bin - has the gemfire-server script /gemfire/lib inside the redis directory is /redis/redis-latest-v.x.y.z.tar /redis/README /readis/install-redis - script that does the basic 4 commands to install redis. There should be a gradle task that runs after the distZip task, that will take the contents of different project directories, script diretories and 'redis-binary' directories and creates the final layout for the distribution. | 5 |
38 | XD-114 | 05/23/2013 12:38:32 | Add install script for Redis | This assumes the redis source tar is available under $rootDir/redis/redis-2.6.13.tar.gz The install script does the following: - Check the platform OS & arch - unzip the tar, compile the sources | 2 |
39 | XD-117 | 05/23/2013 13:36:27 | add spring-integration-groovy to container dependencies | This will enable the use of groovy scripts within modules. | 1 |
40 | XD-119 | 05/23/2013 15:22:22 | HDFS sink should default to hdfs://localhost:8020 | The current default is hdfs://localhost:9000 but most new distributions/installs use 8020 | 1 |
41 | XD-122 | 05/24/2013 17:19:59 | XD scripts need to have spring-integration milestone versions updated | Spring-integration version is changed to 3.0.0.M2 and since we manually create the XD scripts, they still point to the 3.0.0.BUILD-SNAPSHOT version. As discussed, we also need to have a better strategy on updating the lib directory inside the XD scripts. | 2 |
42 | XD-123 | 05/24/2013 17:41:26 | XD scripts lib path needs to be dynamic | We currently have the manually created XD scripts. This makes it difficult to maintain as the lib path is error prone with the changes. We need to make sure that the properties such as lib path etc., are dynamically updated. | 3 |
43 | XD-124 | 05/28/2013 07:58:40 | Clean shutdown of redis in xd-container | Need to shutdown cleanly, no exception messages are shown. Order of components in the stream should be shut down from 'first to last' (opposite of creation) | 2 |
44 | XD-126 | 05/28/2013 08:33:40 | Documentation for sources, sinks, modules should define which attributes are required and which optional | This will eventually be supplied by the admin server, but for now write it up by hand in the documentation | 2 |
45 | XD-128 | 05/28/2013 08:36:05 | Create TCP sink module | Based off SI tcp inbound adapter. This will allow for event fowarding. | 3 |
46 | XD-132 | 05/28/2013 10:47:39 | Profile support for modules | To allow for groups of beans to be defined or not in the container that runs a module. When deploying a stream (e.g. via the REST API), it should be possible to also provide profile names. Then those would apply to any modules within that particular stream deployment. | 8 |
47 | XD-133 | 05/28/2013 10:53:20 | Fail Sonar CI build if there are any package tangles violated. | Similar to what would show up on structure101 reports. | 1 |
48 | XD-134 | 05/28/2013 10:59:31 | Investigate link checking tool for user guide | Asciidoc/doctor might have one as part of it toolchain | 2 |
49 | XD-136 | 05/28/2013 11:03:29 | Documentation that points on how to install hadoop | Pointers to other documentation on how to install hadoop. | 3 |
50 | XD-139 | 05/28/2013 11:33:26 | Update README.txt to include instructions on how to build | Building XD should not be part of the out first out of the box experience, but we should include some instructions on what targets are available, such as distXD. | 2 |
51 | XD-140 | 05/28/2013 12:32:46 | Parameterize syslog Source; Add Support for TCP | The syslog source currently is hard-coded to use udp on port 11111. Need to parameterize the port and provide an option to use TCP. | 2 |
52 | XD-141 | 05/28/2013 13:18:17 | install-redis script should not use relative path to determine redis source dist | Currently, the install-redis script uses relative path to determine redis source dist file. Since this is error prone, we need to fix it. | 1 |
53 | XD-142 | 05/28/2013 15:11:05 | StreamServer Context Lifecycle Issues | The {{ModuleDeployer}} calls {{getBeansOfType}} before the context has had its {{PropertySourcesPlaceholderConfigurer}} attached. This can cause issues with {{FactoryBean}} s with placeholders in constructor args because the unresolved placeholder is used when the {{FactoryBean}} is pre-instantiated to determine the type of object it will serve up. | 8 |
54 | XD-143 | 05/28/2013 16:26:55 | Create externalized property file to support connectivity to redis | We need to have an externalized property file(under xd/conf/) for the xd-container & admin scripts to use as options. | 3 |
55 | XD-146 | 05/29/2013 12:14:17 | Change TCP Source/Sink to Use Profiles | Currently, the TCP source/sink use specific beans for the serializer/deserializer options; when profiles are available, they should be used to avoid having to declare a bean of each type. | 0 |
56 | XD-147 | 05/29/2013 12:45:24 | Remove use of application plugin for redis project | Currently redis project uses application plugin to bundle distribution. This also includes 'java plugin' which causes java specific build behavior on this project. We should try removing the use of application plugin and use something similar or custom tasks that does the bundling. | 2 |
57 | XD-150 | 05/30/2013 00:06:37 | Publish Spring XD final distribution zip as part of Bamboo artifactory plugin | Currently, Bamboo's gradle artifactory plugin has the artifacts configured to projects target(build) directory 'archives'. We need to have a way to set the final distribution archive as one of the gradle 'configurations' in our build.gradle and refer it inside bamboo artifacts. | 2 |
58 | XD-151 | 05/30/2013 08:17:45 | Add Redis binaries for Windows | Presently, Spring XD does not ship Windows binaries for Redis. However, Microsoft is actively working [1] on supporting Redis on Windows. You can download Windows Redis binaries from: https://github.com/MSOpenTech/redis/tree/2.6/bin/release [1] http://blogs.msdn.com/b/interoperability/archive/2013/04/22/redis-on-windows-stable-and-reliable.aspx | 2 |
59 | XD-152 | 05/30/2013 08:23:50 | Create rich gauge module | Spring config for rich gauge plus message handler to coerce a numeric or string payload to a double. | 5 |
60 | XD-153 | 05/30/2013 08:26:06 | create a gauge module | Spring config for simple gauge plus message handler to process message. There is some code common to RichGaugeHandler to coerce the payload to a double that should be refactored for reuse. | 5 |
61 | XD-154 | 05/30/2013 08:32:19 | Provided console output of started server | Shouldn't we have something like a ContextRefreshedEvent Listener and output some informational messages to the console, so the user knows the Container is up (Which contexts. Maybe even print a link to the docs))? Maybe even some simple ascii art (for demos)? Right now it looks somewhat barren. Redis provides something similar. This may even go hand in hand to provided a better configuration model (storing common config parameters centrally) {code} _____ _ __ _______ / ____| (_) \ \ / / __ \ | (___ _ __ _ __ _ _ __ __ _ \ V /| | | | \___ \| '_ \| '__| | '_ \ / _` | > < | | | | ____) | |_) | | | | | | | (_| | / . \| |__| | |_____/| .__/|_| |_|_| |_|\__, | /_/ \_\_____/ | | __/ | |_| v1.0.0.M1 |___/ eXtreme Data Using Redis at localhost:6379 The Server (PID: 12345) is now ready on http://myserver:123/streams Documentation: https://github.com/SpringSource/spring-xd/wiki {code} | 2 |
62 | XD-155 | 05/30/2013 10:26:00 | Add a groovy script processor module | A processor module that accepts either the location of a groovy script resource or an inline script (string). Also some discussion about a default classpath location for scripts. | 5 |
63 | XD-156 | 05/30/2013 10:35:14 | Create config support for Redis | We would like to have Redis driven from a config property file under XD_HOME. | 2 |
64 | XD-159 | 05/30/2013 12:46:58 | Parameter parsing does not work if an argument contains '--'. | Parameter parsing does not work if an argument contains '--'. For example: {code} ... | transform --expression=42 | transform --expression=--payload |... {code} Also, I was surprised that this worked.. {code} | transform --expression=new StringBuilder(payload).reverse() | {code} ... but this didn't... {code} | transform --expression='new StringBuilder(payload).reverse()' | {code} I think we need to tokenize the argument (with ' if contains spaces) and remove any surrounding '...' from the result. This means if someone wants a SpEL literal they would have to use something like {code}--expression=''Hello, world!''{code} resulting in a SpEL literal 'Hello, world!' | 1 |
65 | XD-164 | 05/31/2013 08:46:30 | Validate processing modules declare the required channels | Validate that modules have required channels declared according to their type. Currently the stream deployer accepts processors with no input, but the stream doesn't complete. We should fail earlier and more loudly. | 2 |
66 | XD-166 | 05/31/2013 15:58:00 | Create config support based on channel registry type | We need to have the XD container & admin reading the registry specific property based on the registry type selected. From Mark F, on one of the code review comments: Maybe rather than having redis, rabbit, etc. properties all within a container.properties we should rely upon naming conventions instead. Specifically, we could have a single configurable property for the type of channel registry ("redis", "rabbit", or "local" being possible values), and then we could use something like: <import resource="config/${registry.type}.xml"/> <context:property-placeholder location="config/${registry.type}.properties"/> | 3 |
67 | XD-170 | 06/03/2013 10:50:44 | Home wiki page improvements | Add more structure, more easily find the reference guide. The style that is here https://github.com/snowplow/snowplow/wiki is nice. | 2 |
68 | XD-176 | 06/03/2013 12:19:38 | Support exponential moving average in RichGauge | This could easily be supported in the existing gauge by adding a setAlpha method to RichGaugeService and adding the extra parameter "alpha" to the gauge data (https://en.wikipedia.org/wiki/Exponential_moving_average). If not set it would default to the current behaviour (simple mean), otherwise it would calculate the exponential moving average in place of the mean. | 2 |
69 | XD-178 | 06/03/2013 13:55:23 | DefaultContainer should have a default constructor that generates a UUID | The current incrementAndGet approach based off redis will not easily be applicable in local model deployment | 1 |
70 | XD-179 | 06/03/2013 13:57:55 | Have three startup scripts, xd-singlenode, xd-admin, and xd-container | The xd-singlenode script will launch a main application that creates both the admin node (to process http admin requests) and the container node (to execute modules for data processing) within in the same process the xd-admin script will launch a main application that creates only the admin node (remove current embeddedContainer options) the xd-container script will launch a main application that creates only the container node (as it is now) | 1 |
71 | XD-180 | 06/03/2013 14:04:09 | The command line for xd-admin and xd-container to support an additional option, pipeProtocol, that is used to determine the middleware for sending admin requests and data between processing steps | The name 'pipeProtocol' is tentative. 1. The command line scripts for xd-admin and xd-container would support a --pipeProtocol option, with the default being to use Redis. (Otherwise use xd-singlenode). 2. The xd-admin and xd-container scripts will use the value of pipeProtocol to set the java system property xd.pipeProtocol when launching the app. | 1 |
72 | XD-181 | 06/03/2013 14:07:37 | Update launcher.xml to have protocol independent beans defined and an import statement to load protocol specific defintiions from a system property defined location. | launcher.xml can make use of the system property xd.pipeProtocol inside an import statement. This determines which version of the XD infrastructure to load, for example what ChannelRegistry implementation, Local or Redis based, or specific message listener containers. File name conventions should be used, so if the option passed in from the command line is --pipeProtocol localChannel then the XML filename looked for has the 'Protocol' suffix applied, e.g. localChannelProtocol, and is loaded via the classpath. Redis and Local will not be the only options, other implementations will be provided in the future, e.g. Rabbit, and the user may be able to provide their own implementations of these infrastructure classes (an advanced task). | 3 |
73 | XD-182 | 06/03/2013 14:09:02 | Create redisProtocol.xml that will load all the Redis specific implementations to suppor the XD container runtime and administration | The redis specific beans that are defined in the current launcher.xml should move into this configuration file. | 3 |
74 | XD-185 | 06/03/2013 15:27:19 | Refactor StreamServer to an interface and create Redis and Local implementations | The current StreamServer depends on RedisStreamDeployer. Call this RedisStreamServer and extract interface to allow alternate implementations | 2 |
75 | XD-186 | 06/03/2013 15:31:02 | Create a pipe protocol independent StreamDeployer | Create StreamDeployer that does not depend on an adapter implementation | 2 |
76 | XD-187 | 06/03/2013 18:32:06 | Create XD script for xd-single node | This script will launch XD admin along with the module container. As part of this implementation, we will also remove the embedded options for XD admin & container scripts. | 2 |
77 | XD-190 | 06/04/2013 05:14:13 | Cleanup embedded container story | The --embeddedX options are a bit confusing in code right now, as the Admin can embed the Container and vice-versa. I guess we should only keep the Admin>Container side of things. | 1 |
78 | XD-192 | 06/04/2013 20:18:57 | Update getting started documentation to use xd-singlenode start script. | With the new option of starting without requiring redis, the getting started documentation should reflect this easier way to start processing data. | 2 |
79 | XD-193 | 06/05/2013 05:55:48 | Need more unique resource locations for XD internal configuration | Currently internal config files are in META-INF/spring with fairly generic names. To avoid potential collisions if users add their own configuration in the classpath, we should have a more unique location, e.g. META-INF/spring/xd | 3 |
80 | XD-198 | 06/06/2013 08:50:29 | Documentation for developing streams in the IDE needs to mention including scripts dir to project classpath | {{curl -X POST -d "time --interval=3 | transform | log" http://localhost:8080/streams/test}} results in the following stack trace in the DEBUG log. It's apparently benign, but ugly... {code} 2013-06-06 10:43:36,875 [task-scheduler-1] DEBUG: org.springframework.scripting.support.ResourceScriptSource - class path resource [transform.groovy] could not be resolved in the file system - current timestamp not available for script modification check java.io.FileNotFoundException: class path resource [transform.groovy] cannot be resolved to URL because it does not exist at org.springframework.core.io.ClassPathResource.getURL(ClassPathResource.java:177) at org.springframework.core.io.AbstractFileResolvingResource.lastModified(AbstractFileResolvingResource.java:170) at org.springframework.scripting.support.ResourceScriptSource.retrieveLastModifiedTime(ResourceScriptSource.java:101) at org.springframework.scripting.support.ResourceScriptSource.getScriptAsString(ResourceScriptSource.java:79) at org.springframework.integration.scripting.RefreshableResourceScriptSource.<init>(RefreshableResourceScriptSource.java:46) at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method) at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:39) at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:27) at java.lang.reflect.Constructor.newInstance(Constructor.java:513) at org.springframework.beans.BeanUtils.instantiateClass(BeanUtils.java:147) at org.springframework.beans.factory.support.SimpleInstantiationStrategy.instantiate(SimpleInstantiationStrategy.java:121) at org.springframework.beans.factory.support.ConstructorResolver.autowireConstructor(ConstructorResolver.java:280) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireConstructor(AbstractAutowireCapableBeanFactory.java:1035) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:939) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:485) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:456) at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveInnerBean(BeanDefinitionValueResolver.java:271) at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveValueIfNecessary(BeanDefinitionValueResolver.java:126) at org.springframework.beans.factory.support.ConstructorResolver.resolveConstructorArguments(ConstructorResolver.java:616) at org.springframework.beans.factory.support.ConstructorResolver.autowireConstructor(ConstructorResolver.java:148) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.autowireConstructor(AbstractAutowireCapableBeanFactory.java:1035) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBeanInstance(AbstractAutowireCapableBeanFactory.java:939) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:485) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:456) at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveInnerBean(BeanDefinitionValueResolver.java:271) at org.springframework.beans.factory.support.BeanDefinitionValueResolver.resolveValueIfNecessary(BeanDefinitionValueResolver.java:126) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.applyPropertyValues(AbstractAutowireCapableBeanFactory.java:1360) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.populateBean(AbstractAutowireCapableBeanFactory.java:1118) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(AbstractAutowireCapableBeanFactory.java:517) at org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.createBean(AbstractAutowireCapableBeanFactory.java:456) at org.springframework.beans.factory.support.AbstractBeanFactory$1.getObject(AbstractBeanFactory.java:294) at org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.getSingleton(DefaultSingletonBeanRegistry.java:225) at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:291) at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:193) at org.springframework.beans.factory.support.DefaultListableBeanFactory.preInstantiateSingletons(DefaultListableBeanFactory.java:589) at org.springframework.context.support.AbstractApplicationContext.finishBeanFactoryInitialization(AbstractApplicationContext.java:925) at org.springframework.context.support.AbstractApplicationContext.refresh(AbstractApplicationContext.java:472) at org.springframework.xd.module.SimpleModule.start(SimpleModule.java:97) at org.springframework.xd.dirt.module.ModuleDeployer.deployModule(ModuleDeployer.java:120) at org.springframework.xd.dirt.module.ModuleDeployer.handleMessageInternal(ModuleDeployer.java:108) at org.springframework.integration.handler.AbstractMessageHandler.handleMessage(AbstractMessageHandler.java:73) at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method) at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:597) at org.springframework.expression.spel.support.ReflectiveMethodExecutor.execute(ReflectiveMethodExecutor.java:69) at org.springframework.expression.spel.ast.MethodReference.getValueInternal(MethodReference.java:84) at org.springframework.expression.spel.ast.CompoundExpression.getValueInternal(CompoundExpression.java:57) at org.springframework.expression.spel.ast.SpelNodeImpl.getTypedValue(SpelNodeImpl.java:102) at org.springframework.expression.spel.standard.SpelExpression.getValue(SpelExpression.java:102) at org.springframework.integration.util.AbstractExpressionEvaluator.evaluateExpression(AbstractExpressionEvaluator.java:126) at org.springframework.integration.util.MessagingMethodInvokerHelper.processInternal(MessagingMethodInvokerHelper.java:230) at org.springframework.integration.util.MessagingMethodInvokerHelper.process(MessagingMethodInvokerHelper.java:129) at org.springframework.integration.handler.MethodInvokingMessageProcessor.processMessage(MethodInvokingMessageProcessor.java:73) at org.springframework.integration.handler.ServiceActivatingHandler.handleRequestMessage(ServiceActivatingHandler.java:67) at org.springframework.integration.handler.AbstractReplyProducingMessageHandler.handleMessageInternal(AbstractReplyProducingMessageHandler.java:137) at org.springframework.integration.handler.AbstractMessageHandler.handleMessage(AbstractMessageHandler.java:73) at org.springframework.integration.dispatcher.UnicastingDispatcher.doDispatch(UnicastingDispatcher.java:115) at org.springframework.integration.dispatcher.UnicastingDispatcher.dispatch(UnicastingDispatcher.java:102) at org.springframework.integration.channel.AbstractSubscribableChannel.doSend(AbstractSubscribableChannel.java:77) at org.springframework.integration.channel.AbstractMessageChannel.send(AbstractMessageChannel.java:178) at org.springframework.integration.channel.AbstractMessageChannel.send(AbstractMessageChannel.java:149) at org.springframework.integration.core.MessagingTemplate.doSend(MessagingTemplate.java:304) at org.springframework.integration.core.MessagingTemplate.send(MessagingTemplate.java:165) at org.springframework.integration.endpoint.MessageProducerSupport.sendMessage(MessageProducerSupport.java:92) at org.springframework.integration.x.redis.RedisQueueInboundChannelAdapter.access$4(RedisQueueInboundChannelAdapter.java:1) at org.springframework.integration.x.redis.RedisQueueInboundChannelAdapter$ListenerTask.run(RedisQueueInboundChannelAdapter.java:110) at org.springframework.scheduling.support.DelegatingErrorHandlingRunnable.run(DelegatingErrorHandlingRunnable.java:53) at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:441) at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303) at java.util.concurrent.FutureTask.run(FutureTask.java:138) at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$301(ScheduledThreadPoolExecutor.java:98) at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(ScheduledThreadPoolExecutor.java:206) at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908) at java.lang.Thread.run(Thread.java:662) {code} | 1 |
81 | XD-201 | 06/06/2013 10:40:52 | Fix XD scripts on windows | Currently the XD scripts are broken in windows. | 2 |
82 | XD-206 | 06/06/2013 16:36:59 | XD AdminMain & ContainerMain should check xd.home property from scripts | Currently, the system property xd.home is set as JVM_OPTS (via SPRING_XD_ADMIN_OPTS) into xd-admin & xd-container scripts. Inside the ContainerMain & AdminMain, we need to check if this system property is set and use it. It seems like, this check is missing now. | 1 |
83 | XD-210 | 06/06/2013 21:21:33 | If output directory does not exist for a file sink, by default allow it to be created | There shouldn't be a need to do a mkdir -p before sending data to a file sink. | 1 |
84 | XD-212 | 06/07/2013 08:25:52 | Add http port command line option to AdminMain | Currently StreamServer has setPort, but no way for end user to set it. | 2 |
85 | XD-214 | 06/07/2013 20:56:00 | Create documentation on the general DSL syntax | The asciidoc wiki should have a section (included in the _Sidebar.asciidoc as well) that describes the general usage of the DSL syntax. | 3 |
86 | XD-215 | 06/09/2013 11:42:27 | Add authentication information to twittersearch source doc | Since the changes for XD-202, twittersearch requires authentication. Need to update the docs to reflect this. | 1 |
87 | XD-221 | 06/10/2013 10:33:28 | Links in asciidoctor generated HTML+docbook documentation are broken | The issue arises because the link:document[Label] asciidoc macro is meant for "external documents" and creates {{<ulink>}} in docbook / {{<a href="document">}} in html, whereas we want {{<link linkend="anchor">}} / {{<a href="doc#anchor>}} resp. We also want it to continue working in github live view. I guess what could work is to have the macro (either override the link macro or create our own if github supports that) that looks like : {{link:document#anchor[Label]}} (the #anchor works out of the box in asciidoc and should work in github) but override it for the html and docbook backends to render to the correct form. The thing is, there are several ways to create/override macros (and templates they render to), some of which make sense to our setup: - having asciidoc.conf in the directory of the processed document (http://asciidoc.org/userguide.html#X27) - having docbook.conf/html.conf in the directory of the processed document (http://asciidoc.org/userguide.html#X27) - defining macros using attributes (http://asciidoc.org/userguide.html#_setting_configuration_entries) I tried all of those, but to no avail. These DO WORK with plain asciidoc, but not with our toolchain. Don't know if the problem is with asciidocTOR or with the gradle wrapper though. | 2 |
88 | XD-222 | 06/10/2013 10:37:53 | Add docs for Deleting a simple stream. | curl -X DELETE http://localhost:8080/streams/ticktock | 1 |
89 | XD-226 | 06/11/2013 22:15:18 | Cleanup and Optimize gradle tasks to bundle spring-xd distribution | We need to cleanup some of the duplicate gradle tasks that bundle spring-xd distributions. Currently, distXD does the copy of distributions from "spring-xd-dirt", "redis" and "spring-xd-gemfire-server" projects into "$rootDir/dist/spring-xd". And, the task "zipXD" makes the zip archive. These tasks should be combined with the "distZip" & "docZip" tasks. We also need to remove the duplicate artifacts configuration from these tasks. | 2 |
90 | XD-227 | 06/13/2013 14:19:51 | Add jetty-util-6.1.26.jar and jsr311-api-1.1.1.jar as required jars so they will be on the XD classpath | This is needed for the use of the webhdfs:// scheme to talk to HDFS over http. | 1 |
91 | XD-228 | 06/14/2013 16:26:07 | Missing '=' in example of http stream | In documentation attached to M1, in Streams/Introduction section, there's {noformat} http --port 8091 | file --dir=/tmp/httpdata/ {noformat} while it should be: {noformat} http --port=8091 | file --dir=/tmp/httpdata/ {noformat} missing "{{=}}" in {{http}} | 1 |
92 | XD-236 | 06/17/2013 09:51:52 | Create an Aggregate Counter | An aggregate counter rolls up counts into discrete time buckets. There is an existing POC implementation in Java based off the library https://github.com/thheller/timed-counter The README there has a good description of the desired feature set. | 8 |
93 | XD-244 | 06/17/2013 12:19:32 | Create a Trigger | h2. Narrative As the XD system, I need to be able to execute a job (or potentially a stream) based on a given condition (time, data existence, etc). This story is intended is for a local trigger implementation but remote triggers will also need to exist. h2. Acceptance Criteria # Implement the ability to register a time based trigger {{trigger <CRON_STRING>}} for example # Implement the ability to register a file existence based trigger {{trigger <PATH>}} for example # Implement the ability to execute a job via an anonymous trigger: {{job_name @ <CRON_STRING OR PATH>}} # Implement the ability to execute a job via a job via the previously registered trigger: {{job_name @ trigger_name}} | 8 |
94 | XD-245 | 06/17/2013 12:31:25 | Deploy Batch Jobs on XD | h2. Narrative As a developer, I need a way to deploy job configurations as well as the related custom code to XD. h2. Acceptance Criteria # Provide the ability to register jobs that have been deployed as modules via something like {{curl -d "job" http://localhost:8080/streams/myJob}} where job is the name of the job definition located in /modules/job and myJob is the name of the resulting registered job # Confirm that both "regular" jobs and Spring Hadoop based jobs can be packaged/run. | 8 |
95 | XD-247 | 06/18/2013 06:21:57 | Need to be able to specify password for Redis | Running on Cloud Foundry (and other managed environments) we need to be able to specify a Redis password in addition to host and port. | 2 |
96 | XD-248 | 06/18/2013 06:28:28 | Provide a Spring Shell implementation for XD | Need to create a basic Spring Shell implementation to provide easier access to the XD REST API via an XD REST API Client library. | 0 |
97 | XD-255 | 06/18/2013 06:44:30 | Set up a project for XD Shell | Set up a basic Spring Shell project for XD Shell | 3 |
98 | XD-257 | 06/18/2013 06:47:07 | Create the base implementation for XDCommands for the shell | This is the basic setup of the commands file - no specific command implementations | 3 |
99 | XD-270 | 06/19/2013 09:02:23 | The HDFS Sink should support a file naming strategy to distinguish between file currently being written and completed files | A file that is in the process of being written to should have a customized suffix added to the name, e.g. 'temp'. Once the file is closed, the suffix is removed and replaced with another value - default value can be dependent on the serialization format used, but can be customized | 8 |
100 | XD-271 | 06/19/2013 09:04:47 | The HDFS Sink should support a number of rollover options | A strategy to roll over files that allows the user to choose between 1) the size of the file 2) the number of events/items in the file 3) an idle timeout value that if exceeded, will close the file | 8 |
101 | XD-272 | 06/19/2013 09:06:44 | A rotation file policy based on time | A strategy that will automaticaly roll over files based time of day. For example New files will be created every hour, or every 6 hours etc. The directory for files can also be rotated so that directory structures such as /data/{year}/{month}/{day} can easily be supported with a minimum of configuration. | 0 |
102 | XD-273 | 06/19/2013 09:09:30 | File name should support common date and time format strings | The file name should allow the use of date and time patterns, either JDK or Joda (TBD). | 0 |
103 | XD-274 | 06/19/2013 09:11:34 | Headers in a Message that will indicate which HDFS file the data should be stored in. | Based on message processing, a header in a Message can be added that contains the output file name. This will work together with the hdfs writer module so it can read the header and write the contents of the message to the specified file. | 0 |
104 | XD-275 | 06/19/2013 09:13:18 | Support for in-memory grouping/aggregation of data before writing to HDFS | This should be an optimization, to be verified, that aggregating data in memory, for example at the size of a HDFS block (64Mb often) will result in increased performance vs. not aggregating data for writes. | 0 |
105 | XD-276 | 06/19/2013 09:14:34 | Investigate throughput performance writing to HDFS | This could be an optimization, to be verified, that delegating the writing operations to Reactor (e.g. with a backing ringbuffer implementation) will increase the throughput performance. Other strategies, such as threads to handle writes to individual files concurrently, should be investigated. | 0 |
106 | XD-277 | 06/19/2013 09:15:30 | Support writing to HDFS text file using the BZip2Codec | The BZip2 codec is splittable, making it a common choice. | 0 |
107 | XD-279 | 06/19/2013 09:16:23 | Support writing to HDFS text file using the LZO codec | note, the LZO codes are GPL-licensed, so can't be included in the distribution. It is splittable, which makes it a good candidate for writing without any additional data file container structure such as sequence or avro files. | 0 |
108 | XD-280 | 06/19/2013 09:19:35 | Support writing to HDFS using the Snappy codec | snappy codec can be included in the distribution. for more info http://blog.cloudera.com/blog/2011/09/snappy-and-hadoop/ Depends on using a file container format such as sequence or avro files. | 0 |
109 | XD-281 | 06/19/2013 09:21:03 | Support writing to HDFS using a custom codec | The classname for the codec would be used to instantiate it. Note, the ReflectionUtils or CompressionCodeFactory should be used to be efficient. | 0 |
110 | XD-285 | 06/19/2013 09:31:37 | Provide a strategy interface to obtain the key used when writing SequenceFiles | the key used in writing key-value pairs should be able to be specified declaratively. | 0 |
111 | XD-287 | 06/19/2013 09:32:43 | Support writing to HDFS using Protocol Buffers | See https://github.com/kevinweil/elephant-bird | 0 |
112 | XD-288 | 06/19/2013 09:33:03 | Support writing to HDFS using Thrift | See https://github.com/kevinweil/elephant-bird | 0 |
113 | XD-290 | 06/19/2013 12:12:55 | Redis backed container's RedisQueueInboundChannelAdapter is not performant | Currently, the RedisQueueInboundChannelAdapter has blocking operation when pulling the messages out of redis queue and this is not performant. There are few ideas from the discussion to make it better: 1) Get more items from the redis queue per connection 2) We will also have compression of messages(at the channel registry) before being sent to the redis queue We also need to investigate what redis connection strategy makes the RedisQueueInboundAdapter better. | 2 |
114 | XD-291 | 06/19/2013 12:45:28 | HTTP Source still listens on port 9000 after removal. | Steps to reproduce: 1. curl -d "http | log" http://localhost:8080/streams/testHttp 2. curl -X DELETE http://localhost:8080/streams/testHttp 3. curl -d "http | log" http://localhost:8080/streams/testHttp org.jboss.netty.channel.ChannelException: Failed to bind to: 0.0.0.0/0.0.0.0:9000 | 1 |
115 | XD-295 | 06/21/2013 05:51:34 | redis.properties values ignored | The container application loads {{redis.properties}}, but for some reason the values are ignored, and defaults are used instead. Repro steps: # Unpack Spring XD 1.0.0.M1 to a machine with no running Redis instance # Change /xd/config/redis.properties to specify a different hostname # Run /xd/bin/xd-container # Observe error about inability to connect to Redis on localhost Workaround * Pass -Dredis.hostname={desired IP} as a JVM parameter | 1 |
116 | XD-296 | 06/21/2013 08:13:31 | Add log config file to gemfire in final distro | The changes for XD-144 mean that log4j files are no longer in the library jars. The admin server already has a logging configuration which should be activated by the startup scripts, but the separate gemfire app doesn't. | 1 |
Subsets and Splits