conjur-debify 0.0.1.pre.47 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: 06dab6c897d375466d36efe5f929ab3efad7c98e50b34ce023d4d4fa35e44c50
-  data.tar.gz: d72606df29b7d5befc9cdfe1554ae91f43bfe818324b95b94f9f3f33c8bbfccd
+SHA1:
+  metadata.gz: 7d727bf95156d23c5fdcc395e95fc6308f459632
+  data.tar.gz: 5783389c1eb795cf8c6ee675ce2d2695867f795c
 SHA512:
-  metadata.gz: 43019e747a5f4141e997bd2b07fa08d1affe3296f2fe242d0535fbde09c83860acfd996dad972c031b40d6c85031c0af47eee7e19b2dc426a852b4bb8fa2db55
-  data.tar.gz: 6c2186d8efeb10ecc19816b70106741b9a6101736bbd9f365a7b15b18a355fb0e5db3ba3417d6c87eeb5be962165cc789da777dac4e0795471a225ab0cbb0a5a
+  metadata.gz: 536d4fe0a144a7b88f29fe9d8ac5c437bc934cd1a4db2b5cabbf030a6a54185b451e266b3a98bae203651bb9d27561ecb92d161690adc6477902dbe5a339fc51
+  data.tar.gz: 7b0c04adb847da5ab1ad69463ae5c8027059f9c765bf04896160d661e92b4f42e47fe16189e181e38c2d5a36520be9c25e67094e9c9edc9687e77512d7917d62

data/.gitignore

@@ -1,4 +1,3 @@
-.idea
 features/reports
 /.bundle/
 /.yardoc
@@ -16,6 +15,3 @@ features/reports
 results.html
 mkmf.log
 *.deb
-*.rpm
-*.gem
-docker-debify

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2020 CyberArk Software Ltd. All rights reserved.
+Copyright (c) 2016 Kevin Gilpin
 
 MIT License
 

data/README.md

@@ -1,90 +1,5 @@
 # Debify
 
-Debify is a tool used for building and testing DAP appliance packages.
-It is mainly used to package and publish debian packages that are consumed into the
-appliance image in its build stage. However, it also packages and publishes an
-RPM package whenever it does so for a debian.
-
-## Installation
-
-There are two different ways of installing debify: as a gem, or as a Docker image.
-
-### Installing the gem
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'conjur-debify'
-```
-
-And then execute:
-
-```sh-session
-$ bundle
-```
-
-Or install it yourself as a ruby gem:
-
-```sh-session
-$ gem install conjur-debify
-```
-
-### Installing the Docker image
-Pull the Docker image:
-
-```sh-session
-$ VERSION=3.0.0
-$ docker pull registry.tld/conjurinc/debify:$VERSION
-```
-
-Images are tagged with the version specified in [VERSION](./VERSION)
-
-Use the `config` subcommand to get a copy of the wrapper script and the secret definitions for publishing:
-
-```sh-session
-$ docker run --rm debify:$VERSION config script > docker-debify
-$ chmod +x docker-debify
-# Optionally, if publishing a deb
-$ docker run --rm debify:$VERSION config secrets > publishing-secrets.yml
-```
-
-Running `docker-debify` will then start a container configured to run debify:
-
-```sh-session
-$ ./docker-debify help
-NAME
-    debify - Utility commands for building and testing Conjur appliance Debian packages
-
-SYNOPSIS
-    debify [global options] command [command options] [arguments...]
-
-VERSION
-    3.0.0
-
-
-GLOBAL OPTIONS
-    --env=arg           - Set an environment variable (e.g. TERM=xterm) when starting a container (may be used more than once, default:
-                          none)
-    --help              - Show this message
-    --[no-]local-bundle - Mount local bundle to reuse gems from previous installation
-    --version           - Display the program version
-
-COMMANDS
-    clean          - Clean current working directory of non-Git-managed files
-    config         - Show the given configuration
-    detect-version - Auto-detect and print the repository version
-    help           - Shows a list of commands or help for one command
-    initconfig     - Initialize the config file using current global options
-    package        - Build a debian package for a project
-    publish        - Publish a debian package to apt repository
-    sandbox        - Setup a development sandbox for a Conjur debian package in a Conjur appliance container
-    test           - Test a Conjur debian package in a Conjur appliance container
-```
-
-
-Note that debify itself creates images and starts containers, so it
-needs access to the host's `docker.sock`. Additionally, it requires
-that it be started in root directory of the project being packaged.
-
 ## Build a package
 
 Builds a Conjur Debian package from a Ruby gem.
@@ -96,7 +11,7 @@ NAME
     
 SYNOPSIS
     debify [global options] package [command options] project_name -- <fpm-arguments>
-b
+
 DESCRIPTION
     The package is built using fpm (https://github.com/jordansissel/fpm).
 
@@ -114,7 +29,7 @@ DESCRIPTION
 
 COMMAND OPTIONS
     -d, --dir=arg     - Set the current working directory (default: none)
-    -v, --version=arg - Specify the deb version; by default, it's read from the VERSION file (default: none)
+    -v, --version=arg - Specify the deb version; by default, it's computed from the Git tag (default: none)
 ```
 
 ### Example usage
@@ -168,136 +83,26 @@ COMMAND OPTIONS
 $ debify test -i conjur-appliance-cuke-master --image-tag 4.6-dev --no-pull -d example example test.sh
 ```
 
-## Publish a package
-
-```
-$ debify help publish
-NAME
-    publish - Publish a debian package to apt repository
-
-SYNOPSIS
-    debify [global options] publish [command options] distribution project-name
-
-DESCRIPTION
-    Publishes a deb created with `debify package` to our private apt repository.
-
-    "distribution" should match the major/minor version of the Conjur appliance you want to install to.
-
-    The package name is a required option. The package version can be specified as a CLI option, or it will be auto-detected from Git.
-
-    --component should be 'stable' if run after package tests pass or 'testing' if the package is not yet ready for release. If you don't specify the component, it will be set to
-    'testing' unless the current git branch is 'master' or 'origin/master'. The git branch is first detected from the env var GIT_BRANCH, and then by checking `git rev-parse
-    --abbrev-ref HEAD` (which won't give you the answer you want when detached).
-
-COMMAND OPTIONS
-    -c, --component=arg - Maturity stage of the package, 'testing' or 'stable' (default: none)
-    -d, --dir=arg       - Set the current working directory (default: none)
-    -v, --version=arg   - Specify the deb package version; by default, it's computed automatically (default: none)
-```
-
-### Example usage
-
-You will need read permission for the `ci/artifactory/users/jenkins/username` and `ci/artifactory/users/jenkins/password` variables in order to run this command from your local machine.
-
-```sh-session
-$ debify publish -c stable 0.0.1 example
-[Thread 0] Uploading artifact: https://conjurinc.artifactoryonline.com/conjurinc/debian-local/conjur-example_0.1.1-c9fd618_amd64.deb;deb.distribution=0.1.1;deb.component=possum;deb.architecture=amd64
-[Thread 0] Artifactory response: 201 Created
-Uploaded 1 artifacts to Artifactory.
-```
-
-## Create a development session in a Conjur appliance container
-
-
-```
-$ debify help sandbox
-NAME
-    sandbox - Setup a development sandbox for a Conjur debian package in a Conjur appliance container
-
-SYNOPSIS
-    debify [global options] sandbox [command options] 
-
-DESCRIPTION
-    First, a Conjur appliance container is created and started. By default, the container image is 
-    registry.tld/conjur-appliance-cuke-master. An image tag MUST be supplied. This image
-    is configured with all the CONJUR_ environment variables setup for the local environment (appliance URL, 
-    cert path, admin username and password, etc). The project source tree is
-    also mounted into the container, at /src/<project-name>, where <project-name> is taken from the name of the 
-    current working directory.
-
-    Once in the container, use "/opt/conjur/evoke/bin/dev-install" to install the development bundle of your project. 
-
-COMMAND OPTIONS
-    --bind=arg          - Bind another source directory into the container. Use <src>:<dest>, where both are full paths. (default: none)
-    -d, --dir=arg       - Set the current working directory (default: none)
-    -i, --image=arg     - Image name (default: registry.tld/conjur-appliance-cuke-master)
-    --[no-]pull         - 'docker pull' the Conjur container image
-    -t, --image-tag=arg - Image tag, e.g. 4.5-stable, 4.6-stable (default: none)
-```
-
-### Example usage
-
-```sh-session
-authz $ debify sandbox -t $(cat VERSION_APPLIANCE)-stable
-... much logging
-authz $ docker exec -it authz-sandbox bash
-root@7d4217655332:/src/authz# /opt/conjur/evoke/bin/dev-install authz
-...
-root@7d4217655332:/src/authz# export RAILS_ENV=test
-root@7d4217655332:/src/authz# bundle exec rake db:migrate
-```
-
-## Usage with docker-compose
-
-As of v1.10.0, both the `test` and `sandbox` subcommands support the `--net` switch. This allows you to specify a network to which the Conjur appliance container should be attached. 
-
-There are a variety of ways to make use of this feature. One
-possiblity is creating a network using `docker network create`, then
-attaching both the docker-compose services, as well as the Conjur
-appliance container created by debify, to it. 
-
-As a (somewhat contrived) example, create a new docker network:
-
-```sh-session
-$ docker network create testnet
-```
-
-Use a docker-compose file like [example/docker-compose.yml](example/docker-compose.yml)
-
-```yaml
-version: "2"
-networks:
-  svcnet:
-    external:
-      name: testnet
-services:
-  db:
-    image: postgres
-    container_name: mydb
-    networks:
-      - svcnet
-```
+## Installation
 
-Bring up the db service:
+Add this line to your application's Gemfile:
 
-```sh-session
-debify $ cd example
-example $ docker-compose up -d
+```ruby
+gem 'debify'
 ```
 
-Start a sandbox, see that it can resolve the hostname `mydb`:
+And then execute:
 
-```sh-session
+    $ bundle
 
-example $ debify sandbox -t 5.0-stable --net testnet
-example $ docker exec -it example-sandbox /bin/bash
-root@7d4217655332:/src/example# getent hosts mydb
-172.19.0.2      mydb
-```
+Or install it yourself as:
 
+    $ gem install debify
 
 ## Contributing
 
-For instructions on how to get started and 
-descriptions of our development workflows, please see our
-[contributing guide](CONTRIBUTING.md).
+1. Fork it ( https://github.com/[my-github-username]/debify/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -10,11 +10,6 @@ rescue LoadError
   false
 end
 
-def rspec?
-  require 'rspec/core/rake_task'
-  require 'ci/reporter/rake/rspec'
-end
-  
 Rake::RDocTask.new do |rd|
   rd.main = "README.rdoc"
   rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
@@ -27,20 +22,22 @@ Gem::PackageTask.new(spec) do |pkg|
 end
 
 if cucumber?
-  CUKE_RESULTS = 'features/reports'
+  CUKE_RESULTS = 'results.html'
+  CLEAN << CUKE_RESULTS
 
   desc 'Run features'
   Cucumber::Rake::Task.new(:features) do |t|
-    opts = "features --format junit -o #{CUKE_RESULTS} --format pretty -x"
+    opts = "features --format html -o #{CUKE_RESULTS} --format progress -x"
     opts += " --tags #{ENV['TAGS']}" if ENV['TAGS']
-    t.cucumber_opts = opts
+    t.cucumber_opts =  opts
     t.fork = false
   end
 
   desc 'Run features tagged as work-in-progress (@wip)'
   Cucumber::Rake::Task.new('features:wip') do |t|
+    tag_opts = ' --tags ~@pending'
     tag_opts = ' --tags @wip'
-    t.cucumber_opts = "features --format junit -o #{CUKE_RESULTS} --format pretty -x -s#{tag_opts}"
+    t.cucumber_opts = "features --format html -o #{CUKE_RESULTS} --format pretty -x -s#{tag_opts}"
     t.fork = false
   end
 
@@ -49,8 +46,4 @@ if cucumber?
   task :wip => 'features:wip'
 end
 
-if rspec?
-  desc 'Run specs'
-  RSpec::Core::RakeTask.new(:spec)
-  task :spec => 'ci:setup:rspec'
-end
+task :default => [:features]

data/debify.gemspec

@@ -6,31 +6,22 @@ require 'conjur/debify/version'
 Gem::Specification.new do |spec|
   spec.name          = "conjur-debify"
   spec.version       = Conjur::Debify::VERSION
-  spec.authors       = ["CyberArk Software, Inc."]
-  spec.email         = ["conj_maintainers@cyberark.com"]
+  spec.authors       = ["Kevin Gilpin"]
+  spec.email         = ["kgilpin@conjur.net"]
   spec.summary       = %q{Utility commands to build and package Conjur services as Debian packages}
   spec.homepage      = "https://github.com/conjurinc/debify"
   spec.license       = "MIT"
 
-  spec.files         = `git ls-files -z`.split("\x0").append("VERSION")
+  spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
   
   spec.add_dependency "gli"
-  spec.add_dependency "docker-api", "~> 2.0"
-  spec.add_dependency "conjur-cli" , "~> 6"
-  spec.add_dependency "conjur-api", "~> 5.3"
-  spec.add_development_dependency "bundler", ">= 2.2.30"
-  spec.add_development_dependency "fakefs", "~> 0"
-  spec.add_development_dependency "rake", "~> 13.0"
-  
-  # Pin to cucumbe v2. cucumber v3 changes (breaks) the behavior of
-  # unmatched capture groups with \(d+). In v3, the value of such a
-  # group is 0 instead of nil, which breaks aruba's "I successfully
-  # run...." steps.
-  spec.add_development_dependency "cucumber", '~> 7.1'
-  spec.add_development_dependency "aruba", "~> 2.0"
-  spec.add_development_dependency 'rspec', '~> 3.10'
-  spec.add_development_dependency 'ci_reporter_rspec', '~> 1.0'
+  spec.add_dependency "docker-api"
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "cucumber"
+  spec.add_development_dependency "aruba"
 end

data/example/Gemfile

@@ -1,9 +1 @@
 source 'https://rubygems.org'
-
-group :development do
-  gem 'pry'
-end
-
-group :test do
-  gem 'rspec'
-end

data/example/Gemfile.lock

@@ -1,32 +1,8 @@
 GEM
   remote: https://rubygems.org/
   specs:
-    coderay (1.1.2)
-    diff-lcs (1.3)
-    method_source (0.9.0)
-    pry (0.11.3)
-      coderay (~> 1.1.0)
-      method_source (~> 0.9.0)
-    rspec (3.7.0)
-      rspec-core (~> 3.7.0)
-      rspec-expectations (~> 3.7.0)
-      rspec-mocks (~> 3.7.0)
-    rspec-core (3.7.1)
-      rspec-support (~> 3.7.0)
-    rspec-expectations (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-mocks (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-support (3.7.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  pry
-  rspec
-
-BUNDLED WITH
-   2.1.4

data/example/test.sh

@@ -1,4 +1,3 @@
 #!/bin/bash -ex
 
-ruby -rrspec -e 'puts RSpec::Version::STRING'
 echo Test succeeded

data/features/debify.feature

@@ -0,0 +1,15 @@
+Feature: Packaging
+
+	@announce-output
+	Scenario: 'example' project can be packaged successfully
+		When I run `env DEBUG=true GLI_DEBUG=true debify package -d ../../example -v 0.0.1 example -- --post-install /distrib/postinstall.sh`
+		Then the exit status should be 0
+		And the stdout should contain exactly "conjur-example_0.0.1_amd64.deb"
+
+	@announce-output
+	Scenario: 'example' project can be tested successfully
+		Given I run `env DEBUG=true GLI_DEBUG=true debify package -d ../../example -v 0.0.1 example -- --post-install /distrib/postinstall.sh`
+		And the exit status should be 0
+		When I run `env DEBUG=true GLI_DEBUG=true debify test -t 4.6-stable -d ../../example --no-pull example test.sh`
+		Then the exit status should be 0
+		And the stderr should contain "Test succeeded"

data/features/step_definitions/debify_steps.rb

@@ -1,29 +1,6 @@
-
 When /^I get help for "([^"]*)"$/ do |app_name|
   @app_name = app_name
   step %(I run `#{app_name} help`)
 end
 
 # Add more step definitions here
-
-When /^I start a container named "(.*?)"(?: on network "(.*?)")*$/ do |name, net_name|
-  if net_name
-    network =  Docker::Network.create(net_name)
-    networks << network
-  end
-  
-  options = {
-    'name' => name,
-    'Image' => 'nginx'
-  }
-  options['HostConfig'] = { 'NetworkMode' => net_name } if net_name
-    
-  container = Docker::Container.create(options)
-  container.start!
-  containers << container
-end
-
-When /^I successfully start a sandbox for "(.*?)" with arguments "(.*?)"$/ do |project, args|
-  step %Q{I successfully run `env DEBUG=true GLI_DEBUG=true debify sandbox -d ../../#{project} #{args}`}
-  containers << Docker::Container.get("#{project}-sandbox")
-end

data/features/support/env.rb

@@ -1,12 +1,19 @@
 require 'aruba/cucumber'
-require 'docker-api'
 
 ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
 LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)),'..','..','lib')
 
 Aruba.configure do |config|
-  config.exit_timeout = 1200
-  # not a best practice from aruba's point of view
-  # but the only solution I've found to have docker credentials context
-  config.home_directory = ENV['HOME']
+  config.exit_timeout = 120
+end
+
+Before do
+  # Using "announce" causes massive warnings on 1.9.2
+  @puts = true
+  @original_rubylib = ENV['RUBYLIB']
+  ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
+end
+
+After do
+  ENV['RUBYLIB'] = @original_rubylib
 end

data/jenkins.sh

@@ -0,0 +1,6 @@
+#!/bin/bash -ex
+
+gem install -N bundler
+bundle
+rm -rf features/reports
+cucumber --format pretty --format junit --out features/reports || true

data/lib/conjur/debify/Dockerfile.fpm

@@ -7,6 +7,10 @@ WORKDIR /src/opt/conjur/project
 COPY Gemfile ./
 COPY Gemfile.lock ./
 
+RUN bundle --deployment --without "test development"
+RUN mkdir -p .bundle
+RUN cp /usr/local/bundle/config .bundle/config
+
 COPY . .
 ADD debify.sh /
 

data/lib/conjur/debify/version.rb

@@ -1,5 +1,5 @@
 module Conjur
   module Debify
-    VERSION = File.read(File.expand_path('../../../VERSION', __dir__))
+    VERSION = "0.2.0"
   end
-end
+end