In the redesign process for automation for cygwin in a docker container the following needs to be considered.

Considerations

• Appium or WinAppDriver based scripts
• The inclusion of WinAppDriver in target container.
• Configuration of WinAppDriver ports
• A developer language - Can I use common lisp?
• Scripting of automation

Terms

• A Task a specified activity
• A Documented Structure a solution to Task.
• A Coded Structure a completely coded solution to a Task.

Thoughts

• Proof of concepts demostrates how to perform a certain activity leading to documentation and/or coding of a Task.
• Issues about ports and appium for direct WebAppDriver relate to “the stucture” of the proposed solution to a task.
• A Coded Structure is prefered over a Documented Structure.

Resources

• WinAppDriver Docs page
• WebAppDriver Docs on Appium or WebAppDriver
• Common Lisp Selenium Tutorial

Dynamic variables

Early versions of LISP had Dynamic variables. This distinguished those variable from the Static ones which are largely fixed. Things were fairly simple under this scheme but more complex for the programmers.

Lexical variable and Closures

Later LISPs developed “lexical” bindings where the scope of the variables was limited by enclosing forms with in the text of LISP code, lexical is borrowed from the lexical analsys phase of compilers.

Construct a base cygwin docker environment

Appium install method

Using Appium and inspect.exe script can be written to automate the cygwin download and install.

Phase one is to test that a target can be build, where the source is my machine the appium host. The cygwin image is copied to the target machine from my build host.

Phase two is to see if the build can be done on the target machine directly.

This Critic closed see Cycle 2

Critic of Build a CYGWIN environment in docker.

AddUser needs debugging, fails to work as expected

Build the base CYGWIN environment.

UI Automation

UI Automation is an automation tools for Windows UI. Can a powershell script build the base CYGWIN image?

• Can this be done in the docker windows image? likely no.
• Can cygwin install be automated? likely yes.

UIAutomation.dll how to get it?

Best Instructions

The UIAutomation.dll file is in a cryptic named file which need to be extracted. The best instructions for how are at https://community.spiceworks.com/how_to/160771-how-to-obtain-and-install-uiautomation-dll.

Construct a base cygwin docker environment

The basic method is to choose a windows base environment, next interactively install cygwin in a host directory, use https://www.cygwin.com/setup-x86_64.exe Install apt-cyg from https://github.com/ilatypov/apt-cyg/blob/master/apt-cyg in the docker image. Using docker create an image with the cygwin host directory copied to the guest docker image: use docker cp

Using this process an image was created

https://cloud.docker.com/u/tomrake/repository/docker/tomrake/cygwin

Next iteration

Need to add a normal user.

How to well meaning team got into a conflict

Git for Windows is based on it’s own code on the msys2/mingw-64 code base. The msys2/mingw-64 team uses a patched based contribution system to rebuild it’s system. The msys2/mingw-64 system is built as a series of packages, by a recipe which includes patching of the source code at build time.

Git for windows includes many of the same tool but builds them from a single git repository.

Report on source updating.

A gitlab rebuild is in response to a branch push.

Report on building prototype

An example prototype of a CLISP build system could be libsigsegv

• Prerequisite to CLISP
• Multi platform - release artifacts are
• Git hosted on savanah

How the build(s) are structured

• There is a build interface
• There are instances of Runner for each artifact target.
• Each runner has a tag - the tag is platform/artifact type.

Building CLISP dependencies.

Design a general build process.

• Specify requirements
• build a prototype
• report considerations
• is it suffiencent?
  • Yes - move to a release build
  • No - Report; modify requirement and iterate

Requirements

• artifacts in a docker volume

  • Where docker can find it.
  • Can gitlab find it too?

• source in a docker volume

  • source means current source
  • The source is updatable
  • The source is versionable
  • docker issues ??
  • gitlab issues ??

• build log is accessable

  [Read More]

Building CLISP on gitlab

Attempt to build CLISP on gitlab as a CI project.

Multiple platform support.

CLISP can be built on many platforms. Among them are

• Windows
  • MSC
  • mingw64 - a Unix
  • cygwin - a Unix
• MacOS - I don’t have this.
• Unix
  • Linux
  • FreeBDS

CLISP documentation

For Windows - install.WINDOWS

For UNIX - unix/INSTALL

For Porting general - unix/PLATFORMS

General Approach for docker build

• Create a base platform with all needed dependecies
• Do the configure and build
• Do the tests.
• Export the build artifacts

Each platform is defined by a key string

The build tools are a large case statement based on the key string, or perhaps there is a key.platform statement which tells the specific build conditions and methods.

Church, Turing and von Neuman

Alonzo Church solved the halting problem with the invention of lambda calculus. Alan Turing solved the equivanent problem by the invention of the Turning machine. John Von Neuman proposed an electronic computer based on the Universal Turing Machine to do physics calculation for nuclear fusion evaluation, his model is the basis for our modern computer systems.

FORTRAN and LISP

The first high level compiled language was FORTRAN. First proposed in 1953 the first compiler was delivered in 1957. In 1958 John McCarthy proposed a language LISP which concerned ideas of Church’s lambda calculus. The first compiler was implmented in 1959, during 1962 the first ocmpiler of LISP written completely in LISP was delivered. This was an incremental compiler which piece by piece compiled itself. This began the tradition of the interactive REPL that is part of today’s LISP system, as a consequence the concept of the IMAGE of a LISP system was also developed.