yegor256 / rultor Goto Github PK

Let's create a drain that logs everything to syslog, something like:

com.rultor.drain.Syslog("papertrailapp.com", 53649, "USER")

Let's add a feature of units sharing between accounts (for free and for money)

Let's make a new module rultor-conveyer as a WAR package and host it separately from rultor-web

Let's generate our custom CSS with LESS

Let's add more metrics

Log destinations should be configurable per unit

Let's implement

Let's add Metrics Framework: https://github.com/codahale/metrics

Implement variable references, within one user account.

Let's connect Quartz to SQS to guarantee un-interrupted flow of events

Every instance should run in its single thread and we should prohibit multi-threading

Let's create a health check web page that would show statistics of all components and they health status

Let's enable plain text units, which would start with "text\n" prefix and the rest would be treated as plain text

Let's enable complex masks in Crontab, like "* */5 2,8,12 5-7"

Let's create a new class com.rultor.env.ec2.CFStacks to enable environments instantiation through AWS CloudFormation:

com.rultor.env.ec2.CFStacks(
  "... CF template ...",
  "instance-type", "security-group", "key-pair",
  "AWS-key", "AWS-secret"
)

Let's create a basic set of them

Let's create com.rultor.env.do.Droplets and com.rultor.env.do.Droplet, probably using one of available java APIs:

• https://github.com/2beers/digitalocean-java-api
• https://github.com/marcelocg/do4j
• https://github.com/dgskv/digital-ocean-api-java-wrapper

Let's create environments that upload prerequisites by SSH to every new environment enclosed:

com.rultor.env.SSHPrerequisites(
  original-environments,
  {
    "test.txt": "some text content",
    "img/binary.jpg": com.rultor.data.Base64("0L/RgNC40LLQtdGCIQ==")
    "loaded-through-http.html": com.rultor.data.WebContent("http://www.google.com")
  }
)

Show face() of units in web, if Faceable implemented

Let's create a billboard on top of Amazon SNS

Let's configure papertrailapp explicitly in log4j.properties

Would be convenient to have them, for example:

java.lang.String(
  """
  this is a multi line string
  where all leading spaces are
  automatically removed and trailing
  line endings are preserved
  """
)

And get rid of BigText syntax.

It's a bug, that lead to runtime exception

Such situation should be prevented, because it leads to endless recursion:

foo(bar(), foo)

Let's create a skeleton of all classes

Let's use Amazon SQS for queueing of specs, instead of in-memory queue

Let's show relative time in drain

Let's enable arrays and maps in specs, for example:

com.rultor.base.Abc(
  ["first", "second", com.rultor.base.Test("third")],
  {"first": 12, "second": 34, "third": "something else"}
)

Let's implement a pool of environments in com.rultor.env.Pool

Pulseable object to enable only a certain maximum number of parallel executions

Let's make it parametrized

Instead of stages let's make objects/units persistent in repo

Let's introduce re-usable templates of units. For example, unit foo will look like:

com.Foo($alpha, $beta, "test")

Later, it can be used as:

urn:github:526301:foo("hello", "world")

Let's fix them

Let's add an identifiable label to com.rultor.stateful.sdb.DomainNotepad

The problem is that ClasspathRepo doesn't understand super-types and scalars. For example, if the constructor is defined as

public Foo(int abc, Bar cde) {
  // ...
}

And spec looks like:

Foo(5, ChildOfBar(14))

ClasspathRepo fails to understand them both. It expects a constructor with <init>(long, Bar) signature.

When form submit produces an exception we should stay on the same page, and form fields should be changed

Let's trim S3Log every minute, by removing too old caches

Let's use AWS CloudWatch to collect statistics for every unit

Users should be able to register their own JAR libraries (or maybe source code), in order to use custom pulseable objects.

Let's add an ability to copy a rule

Let's make them searcheable through Amazon CloudSearch

Let's implement an inverse deployment mechanism for conveyer-rultor module. It has to be hosted on a standalone machine (in AWS) and should monitor its own activity. When no threads are busy with any works it has to shut itself down. The system-level bash script should pick it up and start again, fetching the newest version from repository.

Besides, would be nice, before shutting down, to compare its own version with the version published by rultor-web module.

Let's implement paging of pulses in web

RESTful Java client for www.rultor.com

One thread is logging something, another one is trying to flush. They both need key as a lock. Deadlock is inevitable.

Let's publish Maven site to Github pages

OnCommit for SCM management. For example:

OnCommit(branch, rultor-build, sns)
Branch(git, "master") or Branch(svn, "/trunk" or "/branches/test")
Git(servers, "https://...", git-ssh-key)
Subversion(servers, "http://", "user", "password")
ParametrizedBuild(servers, "git checkout …").build(map of params)