Re: Packaging Arcan

Re: Packaging Arcan

[Pierre Neidhardt]

[-- Attachment #1: Type: text/plain, Size: 1184 bytes --]


> 3.a. For qemu, I fear the produced binaries would conflict with the
> original ones. Is there something we can do in the build process to deal
> with that can of thing or sould we just expect the user deal with it on
> its own as Guix doest it very well on its own?

The specialized qemu should be an input to arcan, not a propagated input.
This way it won't conflict with anything.

You might have to configure or patch arcan so that it finds the specialized qemu
binaries in the input store folder.

> 3.b. The patched openal is used during build to produce a special binary
> (arcan_lwa which allows nested servers). It should normally be fetched
> during build time which is obviously not possible here. I suppose there
> is no clear answer here but how would you deal with that kind of
> behaviour? Create a modified openal package? Can we fetch multiple sources?

This happens a lot with other packages (e.g. the Go build system).  The answer
is simple: package the specialized OpenAL and provide it as input.
If arcan still insists on downloading openal, patch it so that it does not.

Hope that helps!

-- 
Pierre Neidhardt
https://ambrevar.xyz/

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 487 bytes --]

Packaging Arcan

[L p R n d n]

[-- Attachment #1: Type: text/plain, Size: 1958 bytes --]


Hello,

I started to package Arcan[1], mostly for fun and trying to learn a bit
more about Guile/Guix. (maybe hoping for guile bindings too. :D)
It mostly works, at least builds, but a few questions arised so here I
am. I join the current WIP patch just in case.

1. Using 'guix lint', I get the same error for all packages:
'the source file name should contain the package name' which I don't
understand. So what's wrong?

2. Arcan server needs some ENV variables to be set to find all its
components. After some search/tries, I ended up using wrap-program which
works. But I stumbled upon 'search-paths' and 'native-search-paths'
along the way. I looked in the manual but I still don't understand there concrete use.
Can someone enlighten me?

3. Arcan uses patched versions of some softwares in certain cases
(openal, qemu and xorg-server) which are all obtained throught dedicated
git repositories. xorg-server seems okay as it mainly produces a binary
called Xarcan. The two others are a little bit ore complicated

3.a. For qemu, I fear the produced binaries would conflict with the
original ones. Is there something we can do in the build process to deal
with that can of thing or sould we just expect the user deal with it on
its own as Guix doest it very well on its own?

3.b. The patched openal is used during build to produce a special binary
(arcan_lwa which allows nested servers). It should normally be fetched
during build time which is obviously not possible here. I suppose there
is no clear answer here but how would you deal with that kind of
behaviour? Create a modified openal package? Can we fetch multiple sources?

4. Licenses seem quite complicated (see COPYING[2]). I added a list of
licenses to the package for now. Is there a better way?

By the way, if someone is interested by this package, every help is
welcomed. ;)

Thanks a lot,

Lprndn

[1] https://arcan-fe.com/
[2] https://github.com/letoram/arcan/blob/master/COPYING


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: 0001-gnu-Add-Arcan.patch --]
[-- Type: text/x-patch, Size: 11624 bytes --]

From 38315df876ba7e60ea078f428bcbfefd8570dd42 Mon Sep 17 00:00:00 2001
From: Lprndn <guix@lprndn.info>
Date: Fri, 23 Nov 2018 12:42:58 +0100
Subject: [PATCH] gnu: Add Arcan.

---
 gnu/packages/arcan.scm | 300 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 300 insertions(+)
 create mode 100644 gnu/packages/arcan.scm

diff --git a/gnu/packages/arcan.scm b/gnu/packages/arcan.scm
new file mode 100644
index 000000000..52b730fa5
--- /dev/null
+++ b/gnu/packages/arcan.scm
@@ -0,0 +1,300 @@
+(define-module (gnu packages arcan)
+  #:use-module (guix packages)
+  #:use-module (guix git-download)
+  #:use-module ((guix licenses) #:prefix license:)
+  #:use-module (guix build-system cmake)
+  #:use-module (guix build-system gnu)
+  #:use-module (guix utils)
+
+  #:use-module (gnu packages pkg-config)
+  #:use-module (gnu packages gl)
+  #:use-module (gnu packages glib)
+  #:use-module (gnu packages libusb)
+  #:use-module (gnu packages pcre)
+  #:use-module (gnu packages lua)
+  #:use-module (gnu packages sdl)
+  #:use-module (gnu packages audio)
+  #:use-module (gnu packages databases)
+  #:use-module (gnu packages apr)
+  #:use-module (gnu packages gtk)
+  #:use-module (gnu packages fontutils)
+  #:use-module (gnu packages video)
+  #:use-module (gnu packages xdisorg)
+  #:use-module (gnu packages autotools)
+  #:use-module (gnu packages ocr)
+  #:use-module (gnu packages compression)
+  #:use-module (gnu packages tls)
+  #:use-module (gnu packages linux)
+  #:use-module (gnu packages xorg)
+  #:use-module (gnu packages freedesktop)
+  #:use-module (srfi srfi-1))
+
+
+(define-public arcan-sdl
+  (package
+   (name "arcan-sdl")
+   (version "0.5.5")
+   (source (origin
+            (method git-fetch)
+            (uri (git-reference
+                  (url "https://github.com/letoram/arcan.git")
+                  (commit "67231da5e736a045cfc0b8db4104351b6bea9774")))
+            (sha256
+             (base32
+              "1ws9fpy6bg0xyblfjca0vyyz1hxm65l99xdfszx3xwa495mss9ix"))))
+   (build-system cmake-build-system)
+   (arguments
+    `(#:configure-flags '("-DVIDEO_PLATFORM=sdl" "-DBUILTIN_LUA=off"
+                          "-DDISABLE_JIT=on" "-DENABLE_LWA=off"
+                          "-DSTATIC_SQLITE3=off" "-DSTATIC_FREETYPE=off"
+                          "-DSHMIF_TUI_ACCEL=on")
+      #:phases
+      (modify-phases %standard-phases
+        (add-before 'configure 'chdir
+          (lambda _
+            (chdir "src")
+            #t))
+        (add-after 'install 'wrap-program
+          (lambda* (#:key outputs #:allow-other-keys)
+            (let ((out (assoc-ref outputs "out")))
+              (wrap-program (string-append out "/bin/arcan")
+                `("ARCAN_RESOURCEPATH" ":" prefix
+                  (,(string-append out "/share/arcan/resources")))
+                `("ARCAN_BINPATH" ":" prefix
+                  (,(string-append out "/bin")))
+                `("ARCAN_SCRIPTPATH" ":" prefix
+                  (,(string-append out "/share/arcan/scripts")))
+                `("ARCAN_APPLBASEPATH" ":" prefix
+                  (,(string-append out "/share/arcan/appl"))))))))
+      #:tests? #f))
+   ;; (native-search-paths
+   ;; '((search-path-specification
+   ;; (variable "ARCAN_RESOURCEPATH")
+   ;; (files '("share/arcan/resources")))
+   ;; (search-path-specification
+   ;; (variable "ARCAN_BINPATH")
+   ;; (files '("bin")))
+   ;; (search-path-specification
+   ;; (variable "ARCANSCRIPTPATH")
+   ;; (files '("share/arcan/scripts")))
+   ;; (search-path-specification
+   ;; (variable "ARCAN_APPLBASEPATH")
+   ;; (files '("share/arcan/appl")))))
+   (inputs
+    `(("pcre" ,pcre)
+      ("glib" ,glib)
+      ("libusb" ,libusb)
+      ("lua" ,lua-5.1)
+      ("sdl" ,sdl)
+      ("vlc" ,vlc)
+      ("openal" ,openal)
+      ("sqlite" ,sqlite)
+      ("apr" ,apr)
+      ("harfbuzz" ,harfbuzz)
+      ("freetype" ,freetype)
+      ("lzip" ,lzip)
+      ("glu" ,glu)
+      ("libxkbcommon" ,libxkbcommon)
+      ("ffmpeg" ,ffmpeg)
+      ("tesseract-ocr" ,tesseract-ocr)))
+   (native-inputs
+    `(("pkg-config" ,pkg-config)))
+   (home-page "https://arcan-fe.com")
+   (synopsis "Combined display server, multimedia framework and game engine (sdl)")
+   (description "Arcan is a powerful development framework for creating virtually
+anything from user interfaces for specialized embedded applications
+all the way to full-blown desktop environments")
+   (license (list license:gpl2+
+                  license:lgpl2.0
+                  license:bsd-3))))
+
+(define-public arcan
+  (package
+    (inherit arcan-sdl)
+    (name "arcan")
+    (inputs
+     `(("libdrm" ,libdrm)
+       ,@(fold alist-delete (package-inputs arcan-sdl)
+               '("sdl"))))
+    (arguments
+     `(#:tests? #f
+       #:configure-flags '("-DVIDEO_PLATFORM=egl-dri" "-DBUILTIN_LUA=off"
+                           "-DDISABLE_JIT=on" "-DENABLE_LWA=off"
+                           "-DSTATIC_SQLITE3=off" "-DSTATIC_FREETYPE=off"
+                           "-DSHMIF_TUI_ACCEL=on")
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'fix-harcoded-cmake-paths
+           (lambda* (#:key inputs #:allow-other-keys)
+             (substitute* "src/platform/cmake/modules/FindGBMKMS.cmake"
+               (("/usr/local/include/libdrm")
+                (string-append (assoc-ref inputs "libdrm")
+                               "/include/libdrm")))
+             (substitute* "src/platform/cmake/modules/FindAPR.cmake"
+               (("/usr/local/apr/include/apr-1")
+                (string-append (assoc-ref inputs "apr")
+                               "/include/apr-1")))
+             #t))
+         (add-before 'configure 'chdir
+           (lambda _
+             (chdir "src")
+             #t))
+         (add-after 'install 'wrap-program
+           (lambda* (#:key outputs #:allow-other-keys)
+             (let ((out (assoc-ref outputs "out")))
+               (wrap-program (string-append out "/bin/arcan")
+                 `("ARCAN_RESOURCEPATH" ":" prefix
+                   (,(string-append out "/share/arcan/resources")))
+                 `("ARCAN_BINPATH" ":" prefix
+                   (,(string-append out "/bin")))
+                 `("ARCAN_SCRIPTPATH" ":" prefix
+                   (,(string-append out "/share/arcan/scripts")))
+                 `("ARCAN_APPLBASEPATH" ":" prefix
+                   (,(string-append out "/share/arcan/appl"))))))))))
+    (synopsis "Combined display server,
+multimedia framework and game engine (egl-dri)")))
+
+(define-public xarcan
+  (package
+    (name "xarcan")
+    (version "0.5.4")
+    (source
+     (origin
+       (method git-fetch)
+       (uri (git-reference
+             (url "https://github.com/letoram/xarcan.git")
+             (commit "8e6ee029388326cfe5cddeffe482eb3702e9b7f3")))
+       (sha256
+        (base32 "0zng7cs6733mnf0p6g5wv02981f2sf567n56csax6cmzb8fpamym"))))
+    (build-system gnu-build-system)
+    (native-inputs
+     `(("pkg-config" ,pkg-config)
+       ("autoconf" ,autoconf)
+       ("automake" ,automake)
+       ("libtool" ,libtool)
+       ("util-macros" ,util-macros)
+       ("font-util" ,font-util)
+       ("xtrans" ,xtrans)
+       ("xkeyboard-config" ,xkeyboard-config)))
+    (inputs
+     `(("pixman" ,pixman)
+       ("libdrm" ,libdrm)
+       ("libx11" ,libx11)
+       ("mesa" ,mesa)
+       ("libressl" ,libressl)
+       ("libxfont2" ,libxfont2)
+       ("libkbfile" ,libxkbfile)
+       ("libepoxy" ,libepoxy)
+       ("arcan" ,arcan)
+       ("xorgproto" ,xorgproto)))
+    (arguments
+     `(#:configure-flags
+       `("--enable-kdrive" "--enable-xarcan"
+         "--disable-xorg" "--disable-xwayland"
+         "--disable-xnest" "--disable-xvfb"
+         "--enable-glamor" "--enable-glx"
+         "--disable-int10-module" "--enable-ipv6"
+         "--enable-record" "--without-systemd-daemon"
+         "--enable-xcsecurity" "--disable-static"
+         ,(string-append "--with-xkb-path="
+                         (assoc-ref %build-inputs "xkeyboard-config")
+                         "/share/X11/xkb")
+         ,(string-append "--with-xkb-output="
+                         "/tmp"))   ; FIXME: This is a bit doubtful; where should
+                                        ; the compiled keyboard maps go?
+
+       #:phases
+       (modify-phases %standard-phases
+         (add-after 'unpack 'noconfigure
+          (lambda _
+            (setenv "NOCONFIGURE" "true")
+            #t)))))
+    (home-page "https://arcan-fe.com")
+    (synopsis "Patched Xserver that bridges connections to Arcan")
+    (description "Patched Xserver that bridges connections to Arcan")
+    (license license:expat)))
+
+(define-public arcan-wayland
+  (package
+    (inherit arcan-sdl)
+    (name "arcan-wayland")
+    (native-inputs
+     `(("pkg-config" ,pkg-config)))
+    (inputs
+     `(("libxkbcommon" ,libxkbcommon)
+       ("libseccomp" ,libseccomp)
+       ("arcan" ,arcan)
+       ("wayland" ,wayland)
+       ("wayland-protocols" ,wayland-protocols)
+       ("mesa" ,mesa)))
+    (arguments
+     `(#:tests? #f
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'chdir
+           (lambda _
+             (chdir "src/tools/waybridge")
+             #t))
+         (add-after 'unpack 'fix-cmake-find-shmif
+           (lambda* (#:key inputs #:allow-other-keys)
+             (substitute* "src/platform/cmake/modules/Findarcan_shmif.cmake"
+               (("/usr/local") (string-append (assoc-ref inputs "arcan") "")))
+             #t)))))
+    (synopsis "Wayland protocol service for Arcan")
+    (description "Wayland protocol service for Arcan")
+    (license license:bsd-3)))
+
+(define-public aclip
+  (package
+    (name "aclip")
+    (version (package-version arcan))
+    (source (package-source arcan))
+    (build-system cmake-build-system)
+    (native-inputs
+     `(("arcan" ,arcan)))
+    (arguments
+     `(#:tests? #f
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'chdir
+           (lambda _
+             (chdir "src/tools/aclip")
+             #t))
+         (add-after 'unpack 'fix-cmake-find-shmif
+           (lambda* (#:key inputs #:allow-other-keys)
+             (substitute* "src/platform/cmake/modules/Findarcan_shmif.cmake"
+               (("/usr/local") (string-append (assoc-ref inputs "arcan") "")))
+             #t)))))
+    (home-page "https://arcan-fe.com")
+    (synopsis "Clipboard manager for Arcan")
+    (description "Clipboard manager for Arcan")
+    (license license:bsd-3)))
+
+(define-public aloadimage
+  (package
+    (name "aloadimage")
+    (version (package-version arcan))
+    (source (package-source arcan))
+    (build-system cmake-build-system)
+    (native-inputs
+     `(("pkg-config" ,pkg-config)))
+    (inputs
+     `(("arcan" ,arcan)
+       ("libseccomp" ,libseccomp)))
+    (arguments
+     `(#:tests? #f
+       #:phases
+       (modify-phases %standard-phases
+         (add-before 'configure 'chdir
+           (lambda _
+             (chdir "src/tools/aloadimage")
+             #t))
+         (add-after 'unpack 'fix-cmake-find-shmif
+           (lambda* (#:key inputs #:allow-other-keys)
+             (substitute* "src/platform/cmake/modules/Findarcan_shmif.cmake"
+               (("/usr/local") (string-append (assoc-ref inputs "arcan") "")))
+             #t)))))
+    (home-page "https://arcan-fe.com")
+    (synopsis "Image viewer for Arcan")
+    (description "Image viewer for Arcan")
+    (license license:bsd-3)))
-- 
2.19.1

Re: Packaging Arcan

[Pierre Neidhardt]

[-- Attachment #1: Type: text/plain, Size: 614 bytes --]


> My bad here, I should have been clearer in my explaination. The patched
> Qemu is not used during build but during runtime. From my understanding,
> it's provided as a way to start X applications under Arcan. The patch is
> probably just used to give qemu the ability to communicate with Arcan
> server. So using 'guix environment' might just be a good solution. (I
> wonder if it could be possible to user guix containers in the same way...)

You might be confused between native-input and input.
Inputs are used at runtime time, unlike native-inputs.

-- 
Pierre Neidhardt
https://ambrevar.xyz/

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 487 bytes --]

Re: Packaging Arcan

[L p R n d n]

Huummm... Hello again,

Forgot something again. :/

So one last question (let's hope).

Arcan load 'appl's which are basically applications written in Lua.
They don't need to be built, just copied to be used as is, so they don't
produce binaries. To start an appl with arcan, you need to 
'arcan $(path-to-appl)'.
Whit Guix paths, it becomes quite complicated to load an appl.
Fortunatly, Arcan allows us to specify an ENV variable with a folder
containing the appls. Knowing that there can be multiple appls, how can
we make them all availabe in the same folder the be able to do:
'arcan $(appl-name)' which would be a lot nicer.

Thanks again,

Lprndn

Re: Packaging Arcan

[L p R n d n]

Thanks Pierre for your quick answer!

Pierre Neidhardt <mail@ambrevar.xyz> writes:

>> 3.a. For qemu, I fear the produced binaries would conflict with the
>> original ones. Is there something we can do in the build process to deal
>> with that can of thing or sould we just expect the user deal with it on
>> its own as Guix doest it very well on its own?
>
> The specialized qemu should be an input to arcan, not a propagated input.
> This way it won't conflict with anything.
>
> You might have to configure or patch arcan so that it finds the specialized qemu
> binaries in the input store folder.
>

My bad here, I should have been clearer in my explaination. The patched
Qemu is not used during build but during runtime. From my understanding,
it's provided as a way to start X applications under Arcan. The patch is
probably just used to give qemu the ability to communicate with Arcan
server. So using 'guix environment' might just be a good solution. (I
wonder if it could be possible to user guix containers in the same way...)

>> 3.b. The patched openal is used during build to produce a special binary
>> (arcan_lwa which allows nested servers). It should normally be fetched
>> during build time which is obviously not possible here. I suppose there
>> is no clear answer here but how would you deal with that kind of
>> behaviour? Create a modified openal package? Can we fetch multiple sources?
>
> This happens a lot with other packages (e.g. the Go build system).  The answer
> is simple: package the specialized OpenAL and provide it as input.
> If arcan still insists on downloading openal, patch it so that it does not.

I'll look iton tis! ;)

> Hope that helps!
>

Lprndn

Re: Packaging Arcan

[Thorsten Wilms]

On 23/11/2018 13.14, L p R n d n wrote:
> 1. Using 'guix lint', I get the same error for all packages:
> 'the source file name should contain the package name' which I don't
> understand. So what's wrong?

I had one such case, where it has been pointed out to me, that using 
git-fetch results in a cryptic filename, unless one adds
(file-name (git-file-name name version))
in the origin form.


-- 
Thorsten Wilms

thorwil's design for free software:
http://thorwil.wordpress.com/

Re: Packaging Arcan

[swedebugia]

Hi :)

On 2018-11-23 13:32, L p R n d n wrote:
> 
> Huummm... Hello again,
> 
> Forgot something again. :/
> 
> So one last question (let's hope).
> 
> Arcan load 'appl's which are basically applications written in Lua.
> They don't need to be built, just copied to be used as is, so they don't
> produce binaries. To start an appl with arcan, you need to
> 'arcan $(path-to-appl)'.
> Whit Guix paths, it becomes quite complicated to load an appl.
> Fortunatly, Arcan allows us to specify an ENV variable with a folder
> containing the appls. Knowing that there can be multiple appls, how can
> we make them all availabe in the same folder the be able to do:
> 'arcan $(appl-name)' which would be a lot nicer.

You have 2 choices as I see it:

1) What about creating a separate package for these without a build stage?
Then they end up in the store and guix can tell the user to set the ENV 
to point to them (see below). This only makes sense if they can be used 
separately from arcan.

2)Alternatively look at the git-definition. It has multiple origin-inputs.

If these are not always needed you could place them in a separate output 
Example from git:

         (add-after 'install 'split
           (lambda* (#:key inputs outputs #:allow-other-keys)
             ;; Split the binaries to the various outputs. 
 

             (let* ((out      (assoc-ref outputs "out"))
                    (se       (assoc-ref outputs "send-email"))))))

This way they don't take up space for those who do not use them.

When the user installs them via e.g. arcan:appl, then they end up in the 
store and guix can tell the user to set the ENV to point to them.

This code in the git definition tells the user to set the correct ENV:

    (native-search-paths 

     (list
	  snip

           (search-path-specification
            (variable "GIT_EXEC_PATH")
            (separator #f)                         ;single entry 
 

            (files '("libexec/git-core")))))

I did not yet package anything that needed this.

Tip: I find the easiest way to find a definition is using emacs-guix -> 
guix-edit -> git.

-- 
Cheers
Swedebugia

PS: writing this I learned something myself about how this works :)

Re: Packaging Arcan

[L p R n d n]

Hello,

Thank you for the help.
I decided to package appls on their own as they are not part of Arcan
itself and can be written by anyone.
My plan, if I understood correctly, is to copy appls file to
'%out/share/arcan/appl' as the folder already exists in Arcan package so
that everything is "merged" in a single folder in the user profile. 
I first thought that setting a search-path in the Arcan package would
then let the user deal with the rest. (Are search-paths honored
automatically under GuixSD?)

But after installing Arcan, 'guix package --search-paths'
doesn't output anything related to the variable I set. I don't have any
hint telling me to set it myself during installation.
Am I misunderstanding something about search-paths?

Here is the piece of code I added to the Arcan definition:
    (search-paths
    '((search-path-specification 
       (variable "ARCAN_APPLBASEPATH")
       (files '("share/arcan/appl")))))
       
Last question here, in a specific appl (Durden), there a little shell
script which set some variables/folders and start arcan. Is it ok to put
it in "%outbin"?

Lprndn

Re: Packaging Arcan

[L p R n d n]

Thank you!
For the record, for OpenAl, I ended up adding the patched version as an
input without packaging it (following the git example given by
swedebugia). Then, copying the files in the right place, the build system
seems to be smart enough to deal with the rest on its own. 
It's one less package to deal with!

Lprndn