@fappy: syntax error, sent you a PR with the fix

Does Boot has something like Leiningen's checkouts for development?

http://jakemccrary.com/blog/2012/03/28/working-on-multiple-clojure-projects-at-once/

@danielsz probably a better doc link for it, but this should help: https://github.com/boot-clj/boot/issues/154

Awesome. Thanks @crisptrutski

My team all came back from their holiday vacations today, and had their first exposure to Boot and our new build system. It went pretty well overall

@seancorfield: great!

Here's a textbook Boot task that should exist (if it doesn't exist already): compress all png's in the fileset with zopfli. https://github.com/google/zopfli

@danielsz: 2.6.0-SNAPSHOT has a better checkouts implementation

@micha: Oh, thank you!

let me know if you have any issues, the checkout task has a couple of quirks

2.6.0-SNAPSHOT has a --checkout option to boot itself

@micha: is this still accurate for 2.6.0-SNAPSHOT; https://github.com/boot-clj/boot/issues/154

it is

we won't make any breaking changes till 3.0.0 which won't be for a long time

so that will continue to work the same

we just added a new --checkouts option to boot that does it a little better i think

Okay, cool, can't wait to try it out, will report back, thanks

hi, I’m looking for an example of a full-stack app which would comprise backend, , SASS stylesheets, live REPL and a way to deploy all these goodies to production

my current knowledge of tooling, esp. boot, doesn’t allow me to come up with my own solution yet

btw checkout https://github.com/danielsz/holygrail

@be9 to include sass just add the boot task i mentioned earlier and compose it

you might need to learn the reloaded workflow but its worth it

what do you mean by «reloaded workflow»? leiningen -> boot?

http://thinkrelevance.com/blog/2013/06/04/clojure-workflow-reloaded

holygrail uses mount which are just pre-configured components

https://clojurians.slack.com/archives/clojurescript/p1451975354010375

https://github.com/stuartsierra/component is a short intro

thanks, I have a small experience with this library

@micha any good boot+docker recipes? or you just add the target directory and that’s it?

usually don't use a target directory at all

the application runs from the classpath

looks like boot serve -p 3000 repl -sp 1337 wait

docker confuses me

more or less

that starts my serve task on port 3000, starts a repl server on port 1337, and then waits forever

(otherwise it would just exit)

the serve task would start a webserver of course

I see, thanks

this works well on things like elastic beanstalk

you can also make uberjar if you want to

and just run that with java -jar

but some of the applications i'm working on use pods internally

so they need to run in boot, currently

ok thanks @micha and @jethroksy, reading boot docs now

👍 good luck!

@micha: what does your Dockerfile look like? looks like I have the chance now to deploy to docker with boot

sure, one sec

https://github.com/adzerk-oss/boot-clj-docker-image/blob/master/Dockerfile

here is the docker image in dockerhub

this has pretty much all the elements in it

it'll roll all your maven deps into the image etc

looks good

thanks!

you can extend that, and just put like ENTRYPOINT ["/usr/bin/boot" "serve" ...

we usually have a start.sh script though

that does some setup of things before starting boot

like getting credentials from the environment to configure external services like datadog

ahh ok

its just gonna be a simple web server that accepts post requests though

serve should be sufficient

yep

cool thing is you can test it locally pretty well

:O how

like if the docker image works locally it'll probably work on beanstalk or whatever

yeah beanstalk is where its going

yeah we use the eb tool to do the actual deploy

with a Dockerrun.aws.json file

and a Dockerfile

ah

dockerrun.aws.json is very minimal:

{
  "AWSEBDockerrunVersion": "1",
  "Ports": [
    {
      "ContainerPort": "80"
    }
  ],
  "Volumes": [],
  "Logging": "/var/log/nginx"
}

wew so many tools to learn

Dockerfile:

FROM adzerk/boot-clj:2.2.0

# Datadog
RUN apt-get update && apt-get install -y adduser
RUN echo 'deb  stable main' > /etc/apt/sources.list.d/datadog.list
RUN apt-key adv --recv-keys --keyserver  C7A7DA52
RUN apt-get update && apt-get install -y datadog-agent

# Application
RUN mkdir /app /app/src app/resources /m2
WORKDIR /app

# next line is for dev
# ADD m2 /m2
ENV BUILT_AT 2015-09-01:15:44:00 # Image checkpoint
ADD src/backend /app/src/backend
ADD resources/config /app/resources/config
ADD start.sh /app/start.sh
ADD src/boot /app/src/boot
COPY build.boot /app/build.boot
COPY boot.properties /app/boot.properties

ENV BOOT_LOCAL_REPO /m2
RUN boot -C serve-proxy # download dependencies

EXPOSE 3000
ENTRYPOINT ["/app/start.sh"]

on my prev app i got frustrated and just used tomcat hahaha

yeah tomcat is good too

especially if you already are familiar with all of its quirks

unfamiliar actually, but didn't give me problems like docker did

this is for a pretty complex application

that dockerfile i pasted

so it has accumulated some things lol

yeah i think I could use the prev one

just change the entry point

yep

well you can just do FROM ...

and then all you need is the entry point

that image is on dockerhub

and EXPOSE i assume

yeah

thanks!

i think that dockerfile is actually generated by boot

lol

you can see the timestamp in there

part of the deploy task

ah

Someone said something about using docker+boot?

I can offer this for reference - https://gitlab.com/jaen/panda5/tree/master

💥

docker compose

this is something i want to learn about

looks like a whole load of overhead to get an image running

With Ruby I used custom scripting that called capistrano + vagrant for controlling docker and it worked quite well, but it would have been to much overhead if you basically only need the jar. So I decided to try out docker compose instead.

Yeah, it's a bit of overhead, some of that comes from being able to actually develop inside the container.

my next app is just gonna be one that accepts a single post request so i was hoping it would be simpler

its a code in an hour, deploy and forget kinda thing

I wrote it that way because only me and a girl from the project were running on Linux in the project, the rest three guys were on Windows and I thought it would be easier for them to just run docker image instead of figuring out how to set-up boot.

(I remember it being a hassle on windows)

for something like that you can juse base your docker image on adzerk/boot-clj and use that dockerrun file i pasted

But in the end the docker didn't work as flawlessly as I hoped xD

ah yes the boot/windows issue

@jethroksy: yeah, in that case I can agree it's a bit too much. You can basically just create the jar and ADD it to the image.

i think its about time someone came along and solved this deployment thing

windows support is improving, little by little

deployment shouldn't be so hard

have you looked at the amazon container service?

it might be simpler

I dunno, this doesn't seem to hard to me, but maybe I'm biased.

There's also heroku or openshift where you can just throw jars at them and they will run it.

a lil' on the pricey end though

i don't personally have money to host things actually

just hit 20 and heading to uni

gonna be in debt for a long time

Openshift and Heroku have free options IIRC.

heroku has that 6h hibernation thing that makes it unusable now

i used up my free openshift one too 😄

Ah

Tough luck then xD

anw i'm sure its not as hard as i think it is

possibly because of my lack of experience deploying

Openshift is pretty cool, apart from having old postgres

If you're heading to university you could probably snag the $50 Digital Ocean credit from Github as well.

AWS isn't as cheap as DO or Linode once you get out of the free tier.

I've used both before

DO was pretty good for rails

@micha: yeah, last time I tried boot on Windows was circa summer, on a friend's tablet running Windows 10 and for the longest time we couldn't figure how to get boot.exe to work.

but this was all before docker came out

Well, it's even better for Java

then army happened and i lost touch with coding

Since you only need to do java -jar uberjar.jar and call it a day.

for all my free heroku deployments java -jar didn't /justwork/ for me

i had to use web: lein ring server-headless

Compulsory army tour where you're from?

conscript army

2 years

haha not much computing in the army

Hah, I've barely dodged that bullet, the year before mine was the last that was conscripted in Poland.

I actually managed servers because of my IT background

but that's all the old legacy stuff

when i needed to make myself useful i'd whip out some computer skills

oracledb with eclipse modules lol

but mostly i didn't tell anyone i knew about computers

Oh God, Oracle D :

could probably get charged with treason if i share too much

xD

cold booting took about 4 hours

haha its always good to pretend not to know stuff

especially in the army

I guess I never really had that choice

one-man deployments

they caught me reading the joy of clojure after automating everything

then that was it for me

subversive samisdat

Well, you can at least be sure the university won't make you a bad programmer, if you already know a sensible progtamming language before heading there : V

Hmm, why didn't java -jar just work in your case? You had to run more processes than just one? Or just not using standalone webserver?

I'm studying local because I plan on starting something this year hopefully

standalone web server

National University of Singapore though

not sure how reputable it is overseas

but apparently its rather prestigious

Ah, so using immutant for example should make your life easier.

does it work with boot-http?

I used it in the repo I linked and as you can see running the app was basically a java -jar plus bunch of Java opts.

hmm i'll give it a shot

Well, you don't really need boot-http in general then.

I mean, that depends on what you're doing as well.

just need it to run the main function i guess

@micha: mind taking a look at https://github.com/adzerk-oss/bootlaces/issues/3#issuecomment-168854386?

oh sure @crisptrutski no problem

Yeah, so you basically can just have some (start-webserver!) function you can call from -main and from REPL that runs immutant - something like`(defn start-webserver! [](immutant/webrun your-handler {:port 4242}))`.

i want to make bootlaces simpler, maybe time for beaking changes there

it makes a lot of assumptions

wondering if task-options! shouldn’t just get some CLI-set-ability in boot itself though

thanks!

via an -o task or env vars

how would that be different than just giving options to the tasks?

for setting options on tasks called indirectly

oh like if the task isn't called directly

yeah

As for universities - NUS can just as well be a good university. I'm probably a bit too soured by having only Pascal, C, C++ and Java on mine and professors mistaking structural programming for FP, because it has you know, functions '

seems like this may indicate some other problem though

in boot-cljs-test i end up passing a lot of options on to boot-cljs, would be nice if those knobs were “free"

we just need to design the bootlaces api better i think

also the push task has too many options

now i think that it would have been better to have a separate check task

i think mine is worse in that it only offers C, C++ and Java

or validate or something

we have too many foreign scholars spoiling the market too

the courses are too standard

Well, that first semester of Pascal was a waste, so you lose nothing of value.

I did take part in IOI

so i got to take the year 3 course

But not having any FP on a university? It is a shame. Good thing you took care of that by yourself though ;' )

it was challenging so I'm kinda looking forward to that

but that's year 3...

I've got saved from being imperatively rotten to the core by a friend who knew Haskell (in his first semester, no less).

I really wanna learn Idris actually

Wow, CS olympics. Hats off. I'm probably not smart enough for that.

but that requires some degree of knowledge of haskell as a transition

and i've been doing too much language hopping

its really not that hard, especially when your country's population is so small

If you want to learn Haskell http://haskellbook.com is awesome. And I don't think language hopping is all that bad either - you get to learn more perspectives on programming.

And to be more ono-topic: one thing you could look into (when you start doing more complex things) is using some sort of components - libs like component/mount/bounce.

Developing applications with reloadable workflow using https://github.com/danielsz/system is pretty cool.

system has immutant so i might use it

Though I'm not sure I like how component pushes you in a more OO-way of writing code, but I didn't yet have chance to try mount or bounce.

OO isn't particularly bad

Well, writing a component for immutant is about ~15 lines of code, so it doesn't buy you much.

its alright if approached correctly

The best thing of that is the system boot task, which gets you this whole reloadable workflow.

component requires a full buy-in though

True

so its not easy to integrate into existing apps

Mount or bounce seem to be an answer to that concern, so I hope to be able to try them in the future.

Well, I don't really like OO because IMO most of the problems it solves are problems that arise from mutability an imperativeness and they can be resolved differently, without requiring objects.

But the problem with OO-ness of component

Is that in Clojure it results in two choices that are equally awkward

Either you have to write all your code inside defrecord which makes you basically write an awkward lispy Java or write free-standign functions, but have to pass the system around and destructure it all the time.

Mount and bounce seems to be better in that regard since they don't force you to use records.

have yet to see what bounce does

If you're interested in looking at it later - https://github.com/jarohen/bounce

It grew out of his previous library, which was monadic, but handling monads in Clojure is considerably more awkward than in Haskell, so he decided to simplify it IIRC.

boot tasks achieve the same thing, in my experience

especially the bounce thing

Interesting. How so?

like running a boot pipeline in the repl

there is the cleanup macro that is the equivalent of being "closeable"

and the scope and all that happens automatically because of the way boot works

you can run your pipeline in a future so it's in the background and bring it back to the foreground by derefing

when you press ctrl-c in the repl it ends the pipeline, which cleans up after itself

But how would that work exactly? Would I write a database task that creates a database connection and an application task that creates the application that depends on the database?

and you can then run it again

Unless I'm misunderstanding something?

Ah, you mean the reloadable part only.

you could, yes

i generally don't like that way of doing things, but it's certainly possible

Hm, I must say I can't really wrap my head around how this could work. But this could be an interesting example of how flexible boot is.

my task is defined as follows:

(deftask run []
  (comp
   (with-pre-wrap fileset
     (edubot.core/-main)
     fileset)
   (wait)))

and I have the barebones immutant stuff up:

(ns edubot.core
  (:gen-class)
  (:require [immutant.web :as web]))

(defn app [request]
  {:status 200
   :body "Hello world!"})

(defn -main []
  (web/run app))

but i get an error when doing boot run

clojure.lang.ExceptionInfo: edubot.core
    data: {:file
           "/var/folders/z2/tkdntvps3z9fyvhxq34gdhkw0000gn/T/boot.user5287752172357405327.clj",
           :line 7}
java.lang.ClassNotFoundException: edubot.core
               ...
boot.main/-main/fn     main.clj: 169
   boot.main/-main     main.clj: 169
               ...
  boot.App.runBoot     App.java: 361
     boot.App.main     App.java: 441
               ...
  boot.Loader.main  Loader.java: 253

oh wait i probably forgot to require it in build.boot

ah ok it works sry for spam

No problem, though won't that break when the pipeline re-runs? You don't seem to stop the server so the port will be taken.

that's my dev task so i just stop it with Ctrl - C

it seems ok to rerun though

Interesting. I thought it would contend on the port if you used watch in pipeline or something.

tbh i'm shamefully unfamiliar with boot internals

when things break i just bash at it

Hah, I'm not much aware how boot works internally exactly either.

clojure is sort of a serious hobby langauge, haven't been using it for long

BTW if you're not using component or something right now, you might be interested in run-dmc - http://immutant.org/documentation/current/apidoc/immutant.web.html#var-run-dmc - it gets you some semblance of reloadability

most tasks are designed to be used in that way

like they clean up after themselves when the pipeline is killed

and they don't do things multiple times if they're run more than once in a pipeline

unless they're supposed to of course

so like servers you start with a delay

which you deref in the task body

and you stop the server in the cleanup expression

good to know!

like boot-jetty, if you run it from the repl

you can kill it and you'll see it shut itself down

so you can then start it again

@micha - you mean this - https://github.com/boot-clj/boot/blob/master/boot/core/src/boot/core.clj#L166-L171?

https://github.com/boot-clj/boot/blob/master/boot/core/src/boot/core.clj#L717-L722

that's the public api thing for it

that other function is not part of the api

https://github.com/tailrecursion/boot-jetty/blob/master/src/tailrecursion/boot_jetty.clj#L39-L42

Oh, I see, that's interesting. TIL

that's basically how i do my reloaded workflow

just delay and cleanup

and tasks of course

it's useful because they have control over the classpath transactionally too, via the fileset

so when you kill the pipline you are back to a clean classpath

pods are destroyed and recreated with a fresh clojure runtime when you start the pipeline again

that boot-jetty task is a little unusual in that the pod is created inside the with-pre-wrap scope

that's a workaround for a different issue

micha: what does https://github.com/boot-clj/boot-bin/blob/master/src/head.sh supposed to return?

if i replace the exec with echo, I get something like java -Dboot.app.path=/home/ben/rpm/rpm2/scripts/head.sh -jar ./head.sh, where the ben/rpm/ blah blah is the path where i put the file

(also, wrt. bash, I have it with /usr/bin/env bash, it's just that nixos doesn't put anything in /bin apart from sh. Everything goes in its own sha hashed path)

@socksy: head.sh gets appended to boot.jar during build

boot.sh is mostly a jar, with that at the front. it's a jar that can exec itself

yes, but what's it supposed to return?

it returns 0 on success, 1 on error - do you mean something else by return?

btw i believe @onetom is a heavy nix user who might be able to help

i meant what is eval'd, as if you take that script and run it with "echo" instead of eval

and good to know, thanks

@socksy: that function i linked to the is-shebang? one

that's where boot decides whether it's running in a shebang script or as boot ...

i think that's probably where it's failing then. That function returns nil for me

@socksy: if you can see where it's going wrong i can include a fix with the next release