Merge pull request #13 from navarasu/fix_12_use_dockerfile

Added Option to use custom docker file for bundling gem

Author: navarasu

examples/using_docker_file/Dockerfile

@@ -0,0 +1,6 @@
+FROM lambci/lambda:build-ruby2.5
+
+RUN yum install -y postgresql-devel
+RUN gem update bundler
+
+CMD "/bin/bash"

examples/using_docker_file/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gem 'pg'

examples/using_docker_file/handler.rb

@@ -0,0 +1,8 @@
+require 'pg'
+
+def hello(event:, context:)
+  { statusCode: 200, body: {
+    "pg_version": PG.library_version
+    }
+  }
+end

examples/using_docker_file/serverless.yml

@@ -0,0 +1,19 @@
+service: using-docker-file 
+
+plugins:
+  - serverless-ruby-layer
+
+custom:
+  rubyLayer:
+    use_docker: true
+    docker_file: Dockerfile
+    native_libs:
+      - /usr/lib64/libpq.so.5
+
+provider:
+  name: aws
+  runtime: ruby2.5
+
+functions:
+  hello:
+    handler: handler.hello

lib/bundle.js

@@ -5,52 +5,70 @@ const Promise = require('bluebird');
 var JSZip = require('jszip');
 Promise.promisifyAll(fs);
 
-function runCommand(cmd,args,options) {
+function runCommand(cmd,args,options,cli) {
   const ps = spawnSync(cmd, args,options);
-  if (ps.error) {
+  cli.log(ps.stdout.toString())
+  if (ps.error  && ps.error.code != 'ENOENT') {
+      cli.log(ps.stderr.toString())
     throw new Error(ps.error);
   } else if (ps.status !== 0) {
+      cli.log(ps.stderr.toString())
     throw new Error(ps.stderr);
   }
   return ps;
 }
 
-function docker(args, options){
-    return runCommand("docker",args,options)
+function docker(args, options,cli){
+    return runCommand("docker",args,options,cli)
 }
 
 function cleanBuild(){
-  this.serverless.cli.log("Cleaning ruby layer build")
-  this.build_path = path.join(this.servicePath,'.serverless','build','ruby_layer')
-  if (fs.pathExistsSync(this.build_path)){
-    fs.rmdirSync(this.build_path,  { recursive: true }) 
+  this.cli = this.serverless.cli
+  this.cli.log("Cleaning ruby layer build")
+  this.ruby_layer = path.join(this.servicePath,'.serverless','ruby_layer')
+  if (fs.pathExistsSync(this.ruby_layer)){
+    fs.rmdirSync(this.ruby_layer,  { recursive: true }) 
   }
 }
-
 function bundleInstall(){
-  this.serverless.cli.log(this.build_path)
-  const gem_path = path.join(this.build_path,'Gemfile')
+  this.cli.log(this.ruby_layer)
+  const gem_path = path.join(this.ruby_layer,'Gemfile')
   fs.copySync(path.join(this.servicePath,'Gemfile'), gem_path )
-  const bundle_args = ['bundle', 'install', '--path=.','--without', 'test', 'development']
-  const options={cwd : this.build_path, encoding : 'utf8'}
+  const bundle_args = ['bundle', 'install', '--path=build','--without', 'test', 'development']
+  const options={cwd : this.ruby_layer, encoding : 'utf8'}
+  this.build_path = path.join(this.ruby_layer, 'build')
+  fs.mkdirSync(this.build_path)
   if (this.options.use_docker) {
     docker_name = 'lambci/lambda:build-'+this.serverless.service.provider.runtime
-    ps=docker(['version'], options)
+    ps=docker(['version'], options,this.cli)
     if (ps.error && ps.error.code === 'ENOENT') {
       throw new Error('docker command not found');
     }
-    args=['run','--rm', '-i','-v', `${this.build_path}:/var/gem_build`, '-w', '/var/gem_build']
+    if (this.options.docker_file) {
+      fs.copySync(path.join(this.servicePath, this.options.docker_file),
+                  path.join(this.ruby_layer,'Dockerfile'))
+      docker_name ='ruby-layer:docker'
+      docker(['build', '-t', docker_name, '-f', 'Dockerfile', '.'], options,this.cli)
+    }
+    if (this.options.native_libs) {
+      ps=docker(['run', '-d', docker_name, 'false'], options,this.cli)
+      container_id = ps.stdout.toString().trim()
+      const lib_path = path.join(this.build_path,'lib')
+      fs.mkdirSync(lib_path)
+      this.options.native_libs.forEach(lib_to_copy => {
+        ps=docker(['cp','-L', container_id+':'+lib_to_copy, lib_path],options,this.cli)
+      })
+    }
+    args=['run','--rm', '-i','-v', `${this.ruby_layer}:/var/gem_build`, '-w', '/var/gem_build']
     args.push(docker_name)
-    ps=docker(args.concat(bundle_args), options)
-    this.serverless.cli.log(ps.stdout)
+    docker(args.concat(bundle_args), options,this.cli)
   } else {
-    ps = runCommand("bundle",['-v'])
+    ps = runCommand("bundle",['-v'],options,this.cli)
     if (ps.error && ps.error.code === 'ENOENT') {
        throw new Error('bundle command not found in local');
     }
-    this.serverless.cli.log(bundle_args.slice(1,bundle_args.length))
-    ps=runCommand(bundle_args[0],bundle_args.slice(1,bundle_args.length),options)
-    this.serverless.cli.log(ps.stdout)
+    this.cli.log(bundle_args.slice(1,bundle_args.length))
+    runCommand(bundle_args[0],bundle_args.slice(1,bundle_args.length),options,this.cli)
   }
 }
 
@@ -91,14 +109,13 @@ function zipBundleFolder() {
   this.gem_folder= fs.readdirSync(path.join(this.build_path,'ruby'))[0]
   fs.rmdirSync(path.join(this.build_path,'ruby',this.gem_folder,'cache'),{ recursive: true })
   const platform = process.platform == 'win32' ? 'DOS' : 'UNIX'
-  return zipDir(path.join(this.build_path,'ruby'),
-                path.join(this.build_path, 'gemLayer.zip'), 
+  return zipDir(this.build_path,
+                path.join(this.ruby_layer, 'gemLayer.zip'),
                 { platform: platform, compression: 'DEFLATE',
                 compressionOptions: { level: 9 }});
 }
 
 function excludePackage(){
-  this.serverless.cli.log(JSON.stringify(this.serverless.service.package))
   if (!this.serverless.service.package){
     this.serverless.service.package = Object.assign({})
   }
@@ -115,7 +132,7 @@ function configureLayer() {
   }
   this.serverless.service.layers['gemLayer'] = Object.assign(
     {
-      package:  {artifact: path.join(this.build_path, 'gemLayer.zip')},
+      package:  {artifact: path.join(this.ruby_layer, 'gemLayer.zip')},
       name: `${
         this.serverless.service.service
       }-${this.serverless.providers.aws.getStage()}-ruby-bundle`,
@@ -129,7 +146,7 @@ function configureLayer() {
   Object.keys(this.serverless.service.functions).forEach(funcName => {
     const function_ = this.serverless.service.getFunction(funcName)
     function_.environment={}
-    function_.environment["GEM_PATH"]="/opt/"+this.gem_folder
+    function_.environment["GEM_PATH"]="/opt/ruby/"+this.gem_folder
     function_.layers = [{"Ref":"GemLayerLambdaLayer"}]
   })
   return Promise.resolve();

package-lock.json

@@ -23,7 +23,7 @@ function readZip(filePath){
                 .then(function (zip) {
                     let check = []
                     zip.forEach(function (relativePath, file){
-                      if (file.dir && relativePath.split(path.sep).length <= 4){
+                      if (file.dir && relativePath.split(path.sep).length <= 5){
                           check.push(relativePath)
                       } else if (relativePath.split(path.sep).length <= 1) {
                             check.push(relativePath)

test/helper.js

@@ -19,7 +19,7 @@ describe('serverless package', function () {
     runCommand('npm',['link','serverless-ruby-layer'],options)
     runCommand('sls',['package'],options)
     let dot_serverless_path = path.join(context_path,'.serverless')
-    let layer_zip_path = path.join(dot_serverless_path,'build','ruby_layer','gemLayer.zip')
+    let layer_zip_path = path.join(dot_serverless_path,'ruby_layer','gemLayer.zip')
     let function_zip_path = path.join(dot_serverless_path,'basic.zip')
     value = readZip(function_zip_path)
             .then(function(data){
@@ -32,7 +32,7 @@ describe('serverless package', function () {
                                 '/gems/','/specifications/','/gems/httparty-0.18.1/',
                                 '/gems/mime-types-3.3.1/','/gems/multi_xml-0.6.0/',
                                 '/gems/mime-types-data-3.2020.0512/']
-                                .map(data => run_time+'.0'+data).sort(),
+                                .map(data => 'ruby/'+run_time+'.0'+data).concat(['ruby/']).sort(),
                                 data.sort())
               })
     let rawdata = fs.readFileSync(path.join(dot_serverless_path,'serverless-state.json'));
@@ -51,6 +51,6 @@ describe('serverless package', function () {
                             })
     assert.deepEqual(cloud_resource['HelloLambdaFunction']['Properties']['Layers'],[ { Ref: 'GemLayerLambdaLayer' } ])
     assert.deepEqual(cloud_resource['HelloLambdaFunction']['Properties']['Environment'],
-                     {Variables: { GEM_PATH: '/opt/'+run_time+'.0'}})
+                     {Variables: { GEM_PATH: '/opt/ruby/'+run_time+'.0'}})
   });
 });