yegor256 / rultor Goto Github PK

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 generate our custom CSS with LESS

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

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

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

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

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

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

Log destinations should be configurable per unit

Let's implement

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

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

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")
  }
)

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

foo(bar(), foo)

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.

Let's create a basic set of them

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 show relative time in drain

Let's create a skeleton of all classes

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

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")

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)

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

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

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.

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

Let's make it parametrized

Let's configure papertrailapp explicitly in log4j.properties

Let's publish Maven site to Github pages

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 billboard on top of Amazon SNS

RESTful Java client for www.rultor.com

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

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

Implement variable references, within one user account.

Let's fix them

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

It's a bug, that lead to runtime exception

Let's implement paging of pulses in web

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

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

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

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

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

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

Let's make them searcheable through Amazon CloudSearch

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

Let's add more metrics

Let's add an ability to copy a rule