prima-twig 0.2.27 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ae2b2439b1eea4e4aab608aec6dc9ead04561c7
-  data.tar.gz: 160d6f697d55a16b005eed9d10e7cbdb51554091
+  metadata.gz: 76aeaf72c0f6f23b244156bcd17bd599d4740ac8
+  data.tar.gz: fe846e2f48d383ee1b2f7a676b72139d578f001f
 SHA512:
-  metadata.gz: 09da201f05deca5428bca7546e0303ec002ecf3f9c4154d74ed5b833a09ed5acc0edceb8a9b3e0ac447e07cd46d8a0826f1bdef729e724f08c5eddc2205f20fe
-  data.tar.gz: 8d4b87e6d48cfb33df31cf21f41e265032cff01b34b2d2ebc6ee87cefed6eb2f8fbeff1c010249f98912df92145489ac3c9bfd398595417b9b491c3657e7a2d3
+  metadata.gz: 67d67bf6c16e34bbb93990e8f8f1b3ca39f6f5afd9474d74c26091b05228059bdbb843e571a8c4aeefc14747dc0589899d9699a1da38b52ebe1f565538e3bf2b
+  data.tar.gz: f97e7ceeb4246ebf87465e3488c223997337c43f20afdddd92a95fad8d8a23c648d6655e92358333293439f7149550f7ea07b13b9fb7ae50e8e44f3a3359ee7b

data/bin/twig-feature

@@ -3,34 +3,33 @@
 require 'rubygems'
 require_relative '../lib/prima_twig.rb'
 require 'launchy'
+require 'digest'
+require 'pp'
 
 class Release
   include Command
 
   def initialize
     @prima = Prima.new
-    @eb = Aws::ElasticBeanstalk::Client.new
+    @cf = Aws::CloudFormation::Client.new
+    @elb = Aws::ElasticLoadBalancing::Client.new
     @ec2 = Aws::EC2::Client.new
-    @s3_bucket = 'elasticbeanstalk-eu-west-1-001575623345'
-    @current_branch_name = @prima.twig.current_branch_name
-    @s3_key = @current_branch_name.gsub('/', '-') + '.zip'
-    @application_name = 'prima-qa'
-    @environment_name = sanitize_environment_name(@s3_key.gsub('.zip', ''))
-    @git_rev = `git rev-parse HEAD`
-    @version_label = @environment_name + '-' + @git_rev[0,5]
-    @user = `git config user.name`.downcase
-    @user = @user[0,1] + @user.split(' ').last
+    @ecs = Aws::ECS::Client.new
+    @s3 = Aws::S3::Client.new
+    @asg = Aws::AutoScaling::Client.new
+    @s3_bucket = 'prima-artifacts'
     @artifact_path = '/tmp/prima-artifact.zip'
-    @ec2_key_name = "eb_#{@user}"
-    @ssh_key_path = "#{ENV['HOME']}/.ssh/eb_#{@user}"
+    @qa_cluster = 'ecs-cluster-qa-ECSCluster-ROF3QJNLOXGG'
+    @import_db_task = 'arn:aws:ecs:eu-west-1:001575623345:task-definition/ecs-task-dbrestore-TaskDefinitionDbRestore-2NOTCW35ZOTF:1'
+    @prima_built = false
+    @urania_built = false
+    @backoffice_built = false
   end
 
   def execute! args
-    possible_args = ["start", "finish", "deploy"]
+    possible_args = ["deploy"]
     stop_if args.empty?, [:wrong_args, possible_args]
-    stop_if args.length > 3, [:wrong_args, possible_args]
-
-    stop_if @prima.head_detached?, :detached_head
+    stop_if args.length > 1, [:wrong_args, possible_args]
 
     case args[0]
     when "start"
@@ -41,8 +40,7 @@ class Release
       if ['terminate', 'stop', 'shutdown', 'halt', 'destroy'].include? args[1]
         deploy_shutdown!
       else
-        ignoranza = args[1] == 'ignorante' ? true : false
-        deploy_feature! ignoranza
+        deploy_feature!
       end
     else
       stop_if true, [:wrong_args, possible_args]
@@ -50,119 +48,274 @@ class Release
   end
 
   def start_feature!
+    branch_name = @prima.clean_branch_name(ask('Inserisci il nome del branch (puoi omettere feature/): '.cyan))
+    stop_unless branch_name.length > 0, 'Devi inserire il nome del branch'
+    branch_name.prepend 'feature/' unless branch_name.include? 'feature'
+
+    output "Il nome del branch sarà " + branch_name.yellow
+
+    exec_step "git checkout master"
+    exec_step "git pull origin master"
+    exec_step "git checkout -b " + branch_name
   end
 
   def finish_feature!
-  end
+    current_branch_name = @prima.twig.current_branch_name
+    stop_unless (current_branch_name =~ /^feature\//), "Non sei su un branch di feature, non posso mergiare nulla"
 
-  def deploy_feature!(ignoranza=false)
+    # Mergia la PR
+    pr = @prima.get_pr
+    stop_unless pr, 'Pull Request not found'
+    @prima.merge_pull_request pr
 
-    stop_if application_version_exists?(@application_name, @version_label), "La versione #{@version_label} esiste gia', ti sei ricordato di committare?".red unless ignoranza
+    output "La Pull Request e' stata mergiata!".green
 
-    manage_ec2_keypair(@ec2_key_name, @ssh_key_path)
+    # Chiude la issue
+    issue_number = @prima.twig.get_branch_property(current_branch_name, 'issue')
+    @prima.close_issue(issue_number) if issue_number
 
-    build_release!
+    # Rimuove il branch remoto
+    exec_step "git push origin :#{current_branch_name}" if @prima.yesno "Vuoi eliminare il branch remoto #{current_branch_name}?".blue
+  end
 
-    exec_step 'rsync -avd --exclude-from app/deploy/aws_docker/qa/.rsync-exclude-qa . /tmp/prima'
-    exec_step 'cd /tmp/prima && cp app/deploy/aws_docker/qa/Dockerrun.aws.json .'
+  def deploy_shutdown!
+    output "Not implemented yet!".red
+    exit
+    # stop_unless environment_exists?(@application_name, @environment_name), "L'environment #{@environment_name} non esiste!"
+    # shutdown_environment(@environment_name) if @prima.yesno("Sei sicuro di voler spegnere l'env?".blue)
+    # output "L'environment #{@environment_name} e' stato disrutto con successo!\n".green
+    # output "Potrebbe comunque passare qualche minuto prima che l'operazione finisca\n".yellow
+  end
 
-    if ignoranza
-      deploy_ignorante
+  def deploy_feature!
+    prima_branch = choose_branch_to_deploy('prima')
+    backoffice_branch = choose_branch_to_deploy('backoffice')
+    urania_branch = choose_branch_to_deploy('urania')
+    socket_branch = {name: "master"}
+    pamela_branch = {name: "master"}
+
+    tags = [
+      {
+        key: "prima",
+        value: prima_branch[:name]
+      },
+      {
+        key: "urania",
+        value: urania_branch[:name]
+      },
+      {
+        key: "backoffice",
+        value: backoffice_branch[:name]
+      }
+    ]
+
+    deploy_id = Digest::MD5.hexdigest(prima_branch[:name] + backoffice_branch[:name] + urania_branch[:name] + socket_branch[:name] + pamela_branch[:name])
+
+    asg_stack_name = "ecs-asg-allinone-qa-#{deploy_id}"
+    create_asg_stack(asg_stack_name) unless stack_exists?(asg_stack_name)
+
+    stack_name_db = "ecs-task-db-qa-#{deploy_id}"
+    stack_body = IO.read('cloudformation/stacks/task/db.json')
+    parameters = [
+      {
+        parameter_key: "Environment",
+        parameter_value: "qa"
+      }
+    ]
+    create_stack(stack_name_db, stack_body, parameters, tags) unless stack_exists?(stack_name_db)
+
+    create_prima_artifact(prima_branch[:revision]) unless artifact_exists?('prima-artifacts', "prima/#{prima_branch[:revision]}")
+    create_urania_artifact(urania_branch[:revision]) unless artifact_exists?('prima-artifacts', "microservices/urania/#{urania_branch[:revision]}-qa.tar.gz")
+
+    wait_for_stack_ready(stack_name_db) unless stack_ready?(stack_name_db)
+
+    import_dbs unless stack_exists?("ecs-task-web-qa-#{deploy_id}")
+
+    stack_name_web = "ecs-task-web-qa-#{deploy_id}"
+    git_checkout_version('prima', prima_branch[:revision])
+    stack_body = IO.read('projects/prima/app/cloudformation/tasks/web.json')
+    parameters = [
+      {
+        parameter_key: "Environment",
+        parameter_value: "qa"
+      },
+      {
+        parameter_key: "ReleaseVersion",
+        parameter_value: prima_branch[:revision]
+      },
+      {
+        parameter_key: "TaskDesiredCount",
+        parameter_value: "1"
+      }
+    ]
+    if stack_exists?(stack_name_web)
+      update_stack(stack_name_web, stack_body, parameters) if @prima_built
     else
-      deploy_serio
+      create_stack(stack_name_web, stack_body, parameters, tags)
     end
 
-    endpoint_url = get_eb_endpoint_url(@application_name, @environment_name)
-    output "Endpoint url: #{endpoint_url}\n".cyan
-    Launchy.open(endpoint_url) if @prima.yesno 'Vuoi aprirlo nel browser?'.blue
-    output "Deploy effettuato, everything is awesome!\n".green
-  end
+    stack_name_consumer = "ecs-task-consumer-qa-#{deploy_id}"
+    git_checkout_version('prima', prima_branch[:revision])
+    stack_body = IO.read('projects/prima/app/cloudformation/tasks/consumer.json')
+    parameters = [
+      {
+        parameter_key: "Environment",
+        parameter_value: "qa"
+      },
+      {
+        parameter_key: "ReleaseVersion",
+        parameter_value: prima_branch[:revision]
+      }
+    ]
+    if stack_exists?(stack_name_consumer)
+      update_stack(stack_name_consumer, stack_body, parameters) if @prima_built
+    else
+      create_stack(stack_name_consumer, stack_body, parameters, tags)
+    end
 
-  def deploy_shutdown!
-    stop_unless environment_exists?(@application_name, @environment_name), "L'environment #{@environment_name} non esiste!"
-    shutdown_environment(@environment_name) if @prima.yesno("Sei sicuro di voler spegnere l'env?".blue)
-    output "L'environment #{@environment_name} e' stato disrutto con successo!\n".green
-    output "Potrebbe comunque passare qualche minuto prima che l'operazione finisca\n".yellow
-  end
+    stack_name_urania = "ecs-task-urania-qa-#{deploy_id}"
+    git_checkout_version('urania', urania_branch[:revision])
+    stack_body = IO.read('projects/urania/deploy/task.json')
+    parameters = [
+      {
+        parameter_key: "Environment",
+        parameter_value: "qa"
+      },
+      {
+        parameter_key: "ReleaseVersion",
+        parameter_value: urania_branch[:revision]
+      },
+      {
+        parameter_key: "TaskDesiredCount",
+        parameter_value: "1"
+      }
+    ]
+    if stack_exists?(stack_name_urania)
+      update_stack(stack_name_urania, stack_body, parameters) if @urania_built
+    else
+      create_stack(stack_name_urania, stack_body, parameters, tags)
+    end
 
-  def deploy_serio
-    exec_step "rm -f #{@artifact_path}; cd /tmp/prima && zip -ryq #{@artifact_path} ."
-    output "Upload dell'artifact in corso (#{(File.size(@artifact_path).to_f / 2**20).round(2)} MiB)\n".yellow
-    s3 = Aws::S3::Resource.new
-    obj = s3.bucket(@s3_bucket).object(@s3_key)
-    obj.upload_file(@artifact_path)
-
-    output "#{@s3_bucket}/#{@s3_key} uploadato con successo!\n".green
-
-    resp = @eb.create_application_version({
-      application_name: @application_name,
-      version_label: @version_label,
-      description: @current_branch_name,
-      source_bundle: {
-        s3_bucket: @s3_bucket,
-        s3_key: @s3_key,
+    # Dev'essere fatto qua perche' dipende dall'url di web
+    create_backoffice_artifact(backoffice_branch[:revision], deploy_id) unless artifact_exists?('prima-artifacts', "backoffice/#{backoffice_branch[:revision]}-#{deploy_id}.zip")
+    git_checkout_version('backoffice', backoffice_branch[:revision])
+    stack_name_backoffice = "ecs-task-backoffice-qa-#{deploy_id}"
+    stack_body = IO.read('projects/backoffice/deploy/task.json')
+    parameters = [
+      {
+        parameter_key: "Environment",
+        parameter_value: "qa"
       },
-      auto_create_application: false,
-    })
+      {
+        parameter_key: "ReleaseVersion",
+        parameter_value: "#{backoffice_branch[:revision]}-#{deploy_id}"
+      },
+      {
+        parameter_key: "TaskDesiredCount",
+        parameter_value: "1"
+      }
+    ]
+    if stack_exists?(stack_name_backoffice)
+      update_stack(stack_name_backoffice, stack_body, parameters) if @backoffice_built
+    else
+      create_stack(stack_name_backoffice, stack_body, parameters, tags)
+    end
 
-    output "Application version #{@version_label} creata con successo!\n".green
+    wait_for_stack_ready(stack_name_web) unless stack_ready?(stack_name_web)
+    wait_for_stack_ready(stack_name_consumer) unless stack_ready?(stack_name_consumer)
+    wait_for_stack_ready(stack_name_urania) unless stack_ready?(stack_name_urania)
+    wait_for_stack_ready(stack_name_backoffice) unless stack_ready?(stack_name_backoffice)
 
-    if environment_exists?(@application_name, @environment_name)
-      is_eb_ready = is_eb_ready?(@application_name, @environment_name)
-      wait_for_eb_ready(@application_name, @environment_name) unless is_eb_ready
-      @eb.update_environment({
-        environment_name: @environment_name,
-        version_label: @version_label
-      })
-      wait_for_eb_ready(@application_name, @environment_name)
-      output "Attendo che i container vengano riavviati...\n".yellow
-      # Non e' veramente ready, deve restartare i container
-      sleep_seconds = 180
-      seconds_elapsed = 0
-      while true
-        break if seconds_elapsed >= sleep_seconds
-        print '.'.yellow; STDOUT.flush
-        sleep 1
-        seconds_elapsed += 1
-      end
-      run_commands(@environment_name, @ssh_key_path)
-    else
-      output "Environment #{@environment_name} non presente, inizio la creazione...\n".yellow
-      create_eb_environment(@application_name, @environment_name, @version_label, @git_rev, @ec2_key_name)
-      output "Environment #{@environment_name} creato!\n".green
-      is_eb_ready = is_eb_ready?(@application_name, @environment_name)
-      wait_for_eb_ready(@application_name, @environment_name) unless is_eb_ready
-      run_commands(@environment_name, @ssh_key_path)
+    update_service_defaults(stack_name_web)
+    update_service_defaults(stack_name_consumer)
+    update_service_defaults(stack_name_urania)
+    update_service_defaults(stack_name_backoffice)
+
+    prima_elb_url = get_elb_url(stack_name_web)
+    urania_elb_url = get_elb_url(stack_name_urania)
+    backoffice_elb_url = get_elb_url(stack_name_backoffice)
+
+    output "Prima url: #{prima_elb_url}\n".cyan
+    output "Urania url: #{urania_elb_url}\n".cyan
+    output "Backoffice url: #{backoffice_elb_url}\n".cyan
+    output "SSH connection: ssh ec2-user@#{ec2_ip_address(asg_stack_name)} -i ~/.ssh/ecs-cluster-qa.pem".cyan
+    output "Deploy effettuato, everything is awesome!\n".green
+  end
+
+  def ec2_ip_address(asg_stack_name)
+    resp = @cf.describe_stack_resource({
+      stack_name: asg_stack_name,
+      logical_resource_id: 'ECSAutoScalingGroup'
+    })
+    resp = @asg.describe_auto_scaling_groups({
+      auto_scaling_group_names: [resp.stack_resource_detail.physical_resource_id],
+      max_records: 1
+    })
+    instance_id = resp.auto_scaling_groups[0].instances[0].instance_id
+    resp = @ec2.describe_instances({instance_ids: [instance_id]})
+    resp.reservations[0].instances[0].private_ip_address
+  end
+
+  def get_elb_url(stack_name)
+    case
+    when stack_name.include?('web')
+      logical_resource_id = 'EcsElasticLoadBalancerPublic'
+    when stack_name.include?('urania')
+      logical_resource_id = 'EcsElasticLoadBalancerInternal'
+    when stack_name.include?('backoffice')
+      logical_resource_id = 'EcsElasticLoadBalancerPublic'
     end
+    resp = @cf.describe_stack_resource({
+      stack_name: stack_name,
+      logical_resource_id: logical_resource_id
+    })
+    resp = @elb.describe_load_balancers({
+      load_balancer_names: [resp.stack_resource_detail.physical_resource_id],
+      page_size: 1
+    })
+    resp.load_balancer_descriptions[0].dns_name
   end
 
-  def deploy_ignorante
-    if environment_exists?(@application_name, @environment_name)
-      public_ip_address = get_ec2_public_ip_address @environment_name
-      is_eb_ready = is_eb_ready?(@application_name, @environment_name)
-      wait_for_eb_ready(@application_name, @environment_name) unless is_eb_ready
-      exec_step "cd /tmp/prima && rsync -azd -e 'ssh -o StrictHostKeyChecking=no -i #{@ssh_key_path}' --rsync-path='sudo rsync' --exclude-from app/deploy/aws_docker/qa/.rsync-exclude-qa . ec2-user@#{public_ip_address}:/var/app/current/"
-      exec_step "ssh -tt -o StrictHostKeyChecking=no -i #{@ssh_key_path} ec2-user@#{public_ip_address} 'sudo rm -rf /var/app/current/app/cache/*'"
-      output "Deploy ignorante effettuato!".green
+  def update_service_defaults(stack_name)
+    case
+    when stack_name.include?('web')
+      logical_resource_id = 'ECSServiceWeb'
+    when stack_name.include?('consumer')
+      logical_resource_id = 'ECSServiceConsumer'
+    when stack_name.include?('urania')
+      logical_resource_id = 'ECSServiceUrania'
+    when stack_name.include?('backoffice')
+      logical_resource_id = 'ECSServiceBackoffice'
     else
-      output "Non puoi fare il deploy ignorante se l'environment non esiste".red
+      raise "Service name non gestito per lo stack #{stack_name}"
     end
+    resp = @cf.describe_stack_resource({
+      stack_name: stack_name,
+      logical_resource_id: logical_resource_id
+    })
+    resp = @ecs.update_service({
+      cluster: @qa_cluster,
+      service: resp.stack_resource_detail.physical_resource_id,
+      deployment_configuration: {
+        minimum_healthy_percent: 0,
+        maximum_percent: 100
+      }
+    })
   end
 
-  def build_release!
+  def create_urania_artifact(revision)
+    @urania_built = true
     output "Preparo l'artifact .zip\n".yellow
 
-    base_cmd = 'docker exec -it prima_'
+    git_checkout_version('urania', revision)
+
+    Dir.chdir 'projects/urania'
+
     [
-      "docker run -v $PWD:/usr/app/src -w /usr/app/src blinkmobile/bower install --allow-root",
-      "#{base_cmd}web_1 composer install",
-      "#{base_cmd}php_1 ./app/console -e=prod assets:install web",
-      "#{base_cmd}php_1 ./app/console -e=prod fos:js-routing:dump",
-      "#{base_cmd}php_1 ./app/console -e=prod cypress:ng-routing:dump",
-      "#{base_cmd}php_1 ./app/console -e=prod bazinga:js-translation:dump web",
-      "#{base_cmd}php_1 ./node_modules/.bin/brunch build -e staging",
-      "#{base_cmd}web_1 composer dump-autoload --optimize --no-dev",
-      "#{base_cmd}compass_1 compass compile --force -c compass/config_prod.rb compass/"
+      "docker run -v $PWD:/code -w /code -e MIX_ENV=qa prima/urania:1.0.2 \
+      'mix local.hex --force && mix hex.info && \
+      mix deps.get && mix compile && mix deps.compile && \
+      mix release.clean --implode --no-confirm && mix release'",
     ].each do |cmd|
       output "Eseguo #{cmd}".yellow
       res = %x[ #{cmd} ]
@@ -174,195 +327,129 @@ class Release
       output res.send color
       stop_if (color == 'red'), "Errore durante la build dell'artifact".red
     end
-  end
 
-  def environment_exists?(application_name, environment_name)
-    resp = @eb.describe_environments({
-      application_name: application_name,
-      environment_names: [environment_name],
-      include_deleted: false
-    })
-    !resp.environments[0].nil?
-  end
+    artifact_path = Dir.glob("rel/urania/releases/*/urania.tar.gz").first
+    upload_artifact(artifact_path, "microservices/urania/#{revision}-qa.tar.gz")
 
-  def shutdown_environment(environment_name)
-    @eb.terminate_environment({
-      environment_name: environment_name,
-      terminate_resources: true
-    })
+    Dir.chdir '../../'
   end
 
-  def manage_ec2_keypair(ec2_key_name, path)
-    path = File.expand_path(path)
-    return if File.exist?(path)
-    stop_unless @prima.yesno("Sei sicuro di voler creare la chiave SSH in #{path}?".blue), "Non puoi continuare senza chiave SSH".red
-    %x[ ssh-keygen -b 2048 -t rsa -f #{path} -q -N '' ]
-    upload_ssh_public_key(ec2_key_name, path + '.pub')
-    output "Chiave SSH creata e uploadata con successo!\n".green
-  end
+  def create_backoffice_artifact(revision, deploy_id)
+    @backoffice_built = true
+    output "Preparo l'artifact .zip\n".yellow
 
-  def upload_ssh_public_key(ec2_key_name, path)
-    @ec2.import_key_pair({
-      dry_run: false,
-      key_name: ec2_key_name,
-      public_key_material: IO.read(path)
-    })
-  end
+    git_checkout_version('backoffice', revision)
+
+    Dir.chdir 'projects/backoffice'
 
-  def create_eb_environment(application_name, environment_name, version_label, git_rev, ec2_key_name)
-    # Faccio in modo di utilizzare sempre l'AMI piu' recente
-    resp = @eb.list_available_solution_stacks
-    latest_solution_stack = {name: '', version: 0.0}
-    resp.solution_stacks.each do |solution_stack|
-      match = solution_stack.match(/64bit Amazon Linux [\d\.]+ v([\d\.]+) running Multi-container Docker [\d\.]+ \(Generic\)/i)
-      if match
-        version = match.captures.first
-        if Gem::Version.new(version) > Gem::Version.new(latest_solution_stack[:version])
-          latest_solution_stack[:name] = solution_stack
-          latest_solution_stack[:version] = version
+    ['node_modules'].each do |dir|
+      unless File.directory?(dir)
+        if File.directory?("../../../backoffice/#{dir}")
+          exec_step "rsync -a ../../../backoffice/#{dir} ."
         end
       end
     end
-    stop_if latest_solution_stack[:name].empty?, "Solution stack non trovata!".red
-    resp = @eb.create_environment({
-      application_name: application_name,
-      environment_name: environment_name,
-      version_label: version_label,
-      solution_stack_name: latest_solution_stack[:name],
-      option_settings: [
-        {
-          namespace: "aws:ec2:vpc",
-          option_name: "VPCId",
-          value: "vpc-72e52b17",
-        },
-        {
-          namespace: "aws:ec2:vpc",
-          option_name: "Subnets",
-          value: "subnet-90dc64f5,subnet-df13e986,subnet-78db7a0f",
-        },
-        {
-          namespace: "aws:ec2:vpc",
-          option_name: "ELBSubnets",
-          value: "subnet-90dc64f5,subnet-df13e986,subnet-78db7a0f",
-        },
-        {
-          namespace: "aws:ec2:vpc",
-          option_name: "AssociatePublicIpAddress",
-          value: "true",
-        },
-        {
-          namespace: "aws:autoscaling:launchconfiguration",
-          option_name: "SecurityGroups",
-          value: "sg-4079f725",
-        },
-        {
-          namespace: "aws:autoscaling:launchconfiguration",
-          option_name: "IamInstanceProfile",
-          value: "prima-qa",
-        },
-        {
-          namespace: "aws:autoscaling:launchconfiguration",
-          option_name: "EC2KeyName",
-          value: ec2_key_name,
-        },
-        {
-          namespace: "aws:autoscaling:launchconfiguration",
-          option_name: "InstanceType",
-          value: "t2.medium",
-        },
-        {
-          namespace: "aws:autoscaling:asg",
-          option_name: "MaxSize",
-          value: "1",
-        },
-        {
-          namespace: "aws:autoscaling:asg",
-          option_name: "MinSize",
-          value: "1",
-        },
-        {
-          namespace: "aws:cloudformation:template:parameter",
-          option_name: "EnvironmentVariables",
-          value: "SYMFONY__PRIMA__GIT__REVISION=#{git_rev},PRIMA_ENV_NAME=web-qa,PARAMETERS_FILE=prima-deploy/parameters_qa.yml,SYMFONY_ENV=qa,PRIMA_ROLE=all",
-        },
-        {
-          namespace: "aws:elasticbeanstalk:application:environment",
-          option_name: "PARAMETERS_FILE",
-          value: "prima-deploy/parameters_qa.yml",
-        },
-        {
-          namespace: "aws:elasticbeanstalk:application:environment",
-          option_name: "PRIMA_ENV_NAME",
-          value: "web-qa",
-        },
-        {
-          namespace: "aws:elasticbeanstalk:application:environment",
-          option_name: "SYMFONY__PRIMA__GIT__REVISION",
-          value: git_rev,
-        }
-      ],
-      tags: [
-        {
-          key: "user",
-          value: @user
-        }
-      ]
-    })
-  end
 
-  def is_eb_ready?(application_name, environment_name)
-    resp = @eb.describe_environments({
-      application_name: application_name,
-      environment_names: [environment_name],
-      include_deleted: false
-    })
-    resp.environments[0].status != 'Launching'
-  end
+    stack_name_web = "ecs-task-web-qa-#{deploy_id}"
+    wait_for_stack_ready(stack_name_web) unless stack_ready?(stack_name_web)
+    web_qa_host = get_elb_url(stack_name_web)
 
-  def get_eb_endpoint_url(application_name, environment_name)
-    resp = @eb.describe_environments({
-      application_name: application_name,
-      environment_names: [environment_name],
-      include_deleted: false
-    })
-    "http://#{resp.environments[0].endpoint_url}"
-  end
+    [
+      "docker-compose build workers",
+      "cd ../../ && docker run -e GIT_DIR=$PWD -v $PWD:/usr/app/src -w /usr/app/src/projects/backoffice blinkmobile/bower install --allow-root",
+      "docker run -v $PWD:/code -w /code --entrypoint /bin/bash backoffice_workers '-c' 'sed -i \"s/web-qa-url/#{web_qa_host}/g\" Gruntfile.js && npm install && grunt qa'",
+    ].each do |cmd|
+      output "Eseguo #{cmd}".yellow
+      res = %x[ #{cmd} ]
+      if $?.exitstatus != 0
+        color = 'red'
+      else
+        color = 'green'
+      end
+      output res.send color
+      stop_if (color == 'red'), "Errore durante la build dell'artifact".red
+    end
 
-  def get_eb_events(application_name, environment_name, start_time=nil, end_time=nil)
-    start_time ||= Time.utc(1980,"jan",1,0,0,0)
-    end_time ||= Time.now + 1
-    resp = @eb.describe_events({
-      application_name: application_name,
-      environment_name: environment_name,
-      start_time: start_time,
-      end_time: end_time
-    })
-    resp.events.reverse
+    artifact_path = '/tmp/backoffice.zip'
+    exec_step "rm -f #{artifact_path} && zip -9 -r #{artifact_path} bin/"
+    upload_artifact(artifact_path, "backoffice/#{revision}-#{deploy_id}.zip")
+
+    Dir.chdir '../../'
   end
 
-  def wait_for_eb_ready(application_name, environment_name)
-    ready = false
-    start_time = Time.now - 60
-    sleep_seconds = 30
-    output "Attendo che l'environment finisca di essere inizializzato...\n".yellow
-    while !ready
-      events = get_eb_events(application_name, environment_name, start_time)
-      start_time = Time.now
+  def create_prima_artifact(revision)
+    @prima_built = true
+    output "Preparo l'artifact .zip\n".yellow
+
+    git_checkout_version('prima', revision)
 
-      print "\n" if events.length > 0
-      STDOUT.flush
+    Dir.chdir 'projects/prima'
 
-      events.each do |event|
-        if ["WARN", "ERROR", "FATAL"].include? event.severity
-          color = 'red'
-        else
-          color = 'cyan'
+    ['vendor', 'node_modules'].each do |dir|
+      unless File.directory?(dir)
+        if File.directory?("../../../prima/#{dir}")
+          exec_step "rsync -a ../../../prima/#{dir} ."
         end
-        output "#{event.event_date} - #{event.severity} #{event.message}".send color
       end
+    end
+
+    base_cmd = 'docker run -v $PWD:/code -w /code --link redis:redis prima_'
+    [
+      "docker-compose build web php",
+      "docker run -d --name redis redis:2.8",
+      "cd ../../ && docker run -e GIT_DIR=$PWD -v $PWD:/usr/app/src -w /usr/app/src/projects/prima blinkmobile/bower install --allow-root",
+      "#{base_cmd}web composer install -n",
+      "#{base_cmd}web npm install",
+      "#{base_cmd}php ./app/console -e=prod assets:install web",
+      "#{base_cmd}php ./app/console -e=prod fos:js-routing:dump",
+      "#{base_cmd}php ./app/console -e=prod cypress:ng-routing:dump",
+      "#{base_cmd}php ./app/console -e=prod bazinga:js-translation:dump web",
+      "#{base_cmd}web ./node_modules/.bin/brunch build -e staging",
+      "#{base_cmd}web composer dump-autoload --optimize --no-dev",
+      "#{base_cmd}compass compass compile --force -c web/compass/config_prod.rb web/compass/",
+      #"docker run -v $PWD:/code -w /code -e NODE_ENV=production prima_web ./node_modules/.bin/webpack --optimize-minimize",
+      "docker kill redis && docker rm redis"
+    ].each do |cmd|
+      output "Eseguo #{cmd}".yellow
+      res = %x[ #{cmd} ]
+      if $?.exitstatus != 0
+        color = 'red'
+      else
+        color = 'green'
+      end
+      output res.send color
+      stop_if (color == 'red'), "Errore durante la build dell'artifact".red
+    end
+
+    exec_step 'rsync -avd --exclude-from app/deploy/aws_docker/qa/.rsync-exclude-qa . /tmp/prima'
+    exec_step "rm -f #{@artifact_path}; cd /tmp/prima && zip -ryq #{@artifact_path} ."
+
+    upload_artifact(@artifact_path, "prima/#{revision}.zip")
+
+    Dir.chdir "../../"
+  end
+
+  def git_checkout_version(project, revision)
+    Dir.chdir "projects/#{project}"
+    exec_step "git checkout -- . && git clean -f -d && git checkout #{revision}"
+    Dir.chdir "../../"
+  end
 
-      ready = true if is_eb_ready?(application_name, environment_name)
+  def upload_artifact(source_path, destination_path)
+    output "Upload dell'artifact in corso (#{(File.size(source_path).to_f / 2**20).round(2)} MiB)\n".yellow
+    s3 = Aws::S3::Resource.new
+    obj = s3.bucket(@s3_bucket).object(destination_path)
+    obj.upload_file(source_path)
+
+    output "#{@s3_bucket}/#{destination_path} uploadato con successo!\n".green
+  end
 
+  def wait_for_stack_ready(stack_name)
+    ready = false
+    sleep_seconds = 10
+    output "Attendo che lo stack #{stack_name} finisca di essere inizializzato...\n".yellow
+    while !ready
+      ready = true if stack_ready?(stack_name)
       seconds_elapsed = 0
       while true
         break if seconds_elapsed >= sleep_seconds
@@ -372,76 +459,139 @@ class Release
       end
     end
 
-    output "Environment inizializzato!\n".green
+    output "\nStack #{stack_name} pronto!\n".green
   end
 
-  def get_ec2_public_ip_address(environment_name)
-    instance_id = @eb.describe_environment_resources({
-      environment_name: environment_name,
-    }).environment_resources.instances[0].id
-
-    resp = @ec2.describe_instances({instance_ids: [instance_id]})
-
-    resp.reservations[0].instances[0].public_ip_address
+  def stack_ready?(stack_name)
+    resp = @cf.describe_stacks({
+      stack_name: stack_name
+    })
+    ['CREATE_COMPLETE', 'UPDATE_COMPLETE'].include? resp.stacks[0].stack_status
   end
 
-  def run_commands(environment_name, ssh_key_path)
-    public_ip_address = get_ec2_public_ip_address environment_name
-
-    output "L'IP pubblico della macchina e': #{public_ip_address}\n".cyan
-
-    base_cmd = "ssh -tt -o StrictHostKeyChecking=no -i #{ssh_key_path} ec2-user@#{public_ip_address}"
-    cmd = "#{base_cmd} sudo -i docker ps --filter='name=-php-' | awk '{print $1 }' | grep -v CONTAINER"
-    container_id = %x[ #{cmd} | grep -v 'Warning:' ].match(/([a-f0-9]{12})/).captures.first
+  def create_asg_stack(stack_name)
+    stack_body = IO.read('cloudformation/stacks/asg/ecs-asg-allinone.json')
+    parameters = [
+      {
+        parameter_key: "Environment",
+        parameter_value: "qa"
+      },
+      {
+        parameter_key: "InstanceType",
+        parameter_value: "t2.large"
+      }
+    ]
+    tags = []
+    create_stack(stack_name, stack_body, parameters, tags)
+  end
 
-    base_docker_cmd = "sudo -i docker exec #{container_id}"
+  def import_dbs
+    resp = @ecs.run_task({
+      cluster: @qa_cluster,
+      task_definition: @import_db_task,
+      count: 1
+    })
+    output "Attendo che i DB vengano importati...\n".yellow
+    stopped_at = nil
+    while stopped_at.nil?
+      resp = @ecs.describe_tasks({
+        cluster: @qa_cluster,
+        tasks: [resp.tasks[0].task_arn]
+      })
+      stopped_at = resp.tasks[0].stopped_at
+      sleep_seconds = 10
+      seconds_elapsed = 0
+      while true && stopped_at.nil?
+        break if seconds_elapsed >= sleep_seconds
+        print '.'.yellow; STDOUT.flush
+        sleep 1
+        seconds_elapsed += 1
+      end
+    end
+    print "\n"
+  end
 
-    [
-      "#{base_cmd} #{base_docker_cmd} ./app/console fos:elastica:reset --force",
-      "#{base_cmd} #{base_docker_cmd} ./app/console doctrine:database:drop --no-interaction --force",
-      "#{base_cmd} #{base_docker_cmd} ./app/console doctrine:database:create --no-interaction",
-      "#{base_cmd} #{base_docker_cmd} ./app/console doctrine:database:drop --no-interaction --connection=msa --force; true",
-      "#{base_cmd} #{base_docker_cmd} ./app/console doctrine:database:create --no-interaction --connection=msa",
-      "#{base_cmd} #{base_docker_cmd} ./app/console doctrine:schema:create --no-interaction",
-      "#{base_cmd} #{base_docker_cmd} ./app/console doctrine:fixtures:load --no-interaction --fixtures=src/Prima/DataFixtures/"
-    ].each do |cmd|
-      output "Eseguo #{cmd}".yellow
-      res = %x[ #{cmd} ]
-      if $?.exitstatus != 0
-        color = 'red'
+  def stack_exists?(stack_name)
+    begin
+      res = @cf.describe_stacks({
+        stack_name: stack_name
+      })
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      if e.message.include? 'does not exist'
+        false
       else
-        color = 'green'
+        raise e
       end
-      output res.send color
+    else
+      true
     end
   end
 
-  def application_version_exists?(application_name, version_label)
-    resp = @eb.describe_application_versions({
-      application_name: application_name,
-      version_labels: [ version_label ]
+  def create_stack(stack_name, stack_body, parameters = [], tags = [])
+    @cf.create_stack({
+      stack_name: stack_name,
+      template_body: stack_body,
+      parameters: parameters,
+      tags: tags,
+      capabilities: ["CAPABILITY_IAM"],
+      on_failure: "ROLLBACK"
     })
-    !resp.application_versions[0].nil?
+    output "La creazione dello stack #{stack_name} è stata avviata".green
   end
 
-  def sanitize_environment_name(environment_name)
-    environment_name.gsub!(/([^\w]|_)/, '-')
-    if environment_name.length > 23
-      if environment_name.start_with?('feature')
-        environment_name = environment_name[8,23]
-      elsif environment_name.start_with?('hotfix')
-        environment_name = environment_name[7,23]
-      else
-        environment_name = environment_name[0,23]
-      end
-    end
-    if environment_name[0] == '-'
-      environment_name = environment_name[1..-1]
+  def update_stack(stack_name, stack_body, parameters = [])
+    begin
+      @cf.update_stack({
+        stack_name: stack_name,
+        template_body: stack_body,
+        parameters: parameters,
+        capabilities: ["CAPABILITY_IAM"]
+      })
+    rescue Aws::CloudFormation::Errors::ValidationError => e
+      # if e.message.include? 'does not exist'
+      #   false
+      # else
+      #   raise e
+      # end
+      raise e
+    else
+      output "L'update dello stack #{stack_name} è stato avviato".green
     end
-    if environment_name[-1] == '-'
-      environment_name = environment_name[0..-2]
+  end
+
+  def artifact_exists?(bucket, path)
+    resp = @s3.list_objects({
+      bucket: bucket,
+      max_keys: 1,
+      prefix: path
+    })
+    !resp.contents.empty?
+  end
+
+  def choose_branch_to_deploy(project_name)
+    Dir.chdir "projects/#{project_name}"
+    output "Recupero la lista dei branch del progetto #{project_name}..."
+    out = %x[ git fetch ]
+    branches = %x[ git for-each-ref --sort=-committerdate refs/remotes/ --format='%(refname) %(objectname)' | sed 's/refs\\/remotes\\/origin\\///g' ]
+      .split("\n").delete_if { |b| b.include?('HEAD') || b.include?('dev') }
+
+    branch_name = choose do |menu|
+      menu.prompt = "Scegli il branch di #{project_name} da deployare: ".cyan
+      menu.shell  = true
+
+      branches.each do |branch|
+
+        title = @prima.reduce_size(branch, 100)
+        msg = "#{title}".light_blue
+        menu.choice(msg) { branch }
+      end
     end
-    environment_name
+
+    Dir.chdir "../../"
+
+    name = branch_name.split(' ').first
+    revision = branch_name.split(' ').last
+    { name: name, revision: revision[0..14] }
   end
 
 end