Creates the given deployment.
@param applicationId The application id for the deployments
@param deployment The deployment to create
@return The deployment that was created
427555
public Optional<Deployment> create(long applicationId, Deployment deployment)
    {
        return HTTP.POST(String.format("/v2/applications/%d/deployments.json", applicationId), deployment, DEPLOYMENT);
    }
779595
public Optional<ApplicationInstance> show(long applicationId, long instanceId)
    {
        return HTTP.GET(String.format("/v2/applications/%d/instances/%d.json", applicationId, instanceId), APPLICATION_INSTANCE);
    }
163128
public Container deploy(Archive<?> deployment) throws DeploymentException {
        if (!this.running) {
            throw new RuntimeException("The Container has not been started.");
        }

        this.deployer.deploy(deployment);

        return this;
    }
1240875
def set_deployment_id(self):
        
        log = logging.getLogger(self.cls_logger + '.set_deployment_id')
        deployment_id_val = self.get_value('cons3rt.deployment.id')
        if not deployment_id_val:
            log.debug('Deployment ID not found in deployment properties')
            return
        try:
            deployment_id = int(deployment_id_val)
        except ValueError:
            log.debug('Deployment ID found was unable to convert to an int: {d}'.format(d=deployment_id_val))
            return
        self.deployment_id = deployment_id
        log.info('Found deployment ID: {i}'.format(i=str(self.deployment_id)))
325164
public void setApplicationId(String applicationId) {
		// Set the application id as a GeoPackage
		int applicationIdInt = ByteBuffer.wrap(applicationId.getBytes())
				.asIntBuffer().get();
		execSQL(String.format("PRAGMA application_id = %d;", applicationIdInt));
	}
457579
@TaskAction
  public void deployAction() throws AppEngineException {
    DeployConfiguration deployConfig =
        deployExtension.toDeployConfiguration(ImmutableList.of(appYaml));
    gcloud.newDeployment(CloudSdkOperations.getDefaultHandler(getLogger())).deploy(deployConfig);
  }
804969
private static CommandLine createCommandLine(DeploymentEntry deployment, Options commandLineOptions) {
		try {
			return deployment.getCommandLine(commandLineOptions);
		} catch (Exception e) {
			throw new SqlExecutionException("Invalid deployment options.", e);
		}
	}
823729
@Override
	public WebApplicationInfo createWebApplicationInfo(String webServerName, String applicationID, String contextRoot) {
		return WebApplicationInfoNoop.INSTANCE;
	}
728169
public static Deployment of(final URL url) {
        final DeploymentContent deploymentContent = DeploymentContent.of(Assert.checkNotNullParam("url", url));
        return new Deployment(deploymentContent, null);
    }
952556
@Override
    public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {

        final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
        List<ResourceRoot> resourceRoots = DeploymentUtils.allResourceRoots(deploymentUnit);
        for (ResourceRoot resourceRoot : resourceRoots) {
            if (IgnoreMetaInfMarker.isIgnoreMetaInf(resourceRoot)) {
                continue;
            }
            Manifest manifest = getManifest(resourceRoot);
            if (manifest != null)
                resourceRoot.putAttachment(Attachments.MANIFEST, manifest);
        }
    }
283239
public Container deploy() throws DeploymentException {
        Archive deployment = createDefaultDeployment();
        if (deployment == null) {
            throw new DeploymentException("Unable to create default deployment");
        } else {
            return deploy(deployment);
        }
    }
1296139
@Override
    public void awaitApplicationReadinessOrFail(final String applicationName) {
        await().atMost(5, TimeUnit.MINUTES).until(() -> {
                return getClient()
                    .deploymentConfigs()
                    .inNamespace(this.namespace)
                    .withName(applicationName).isReady();
            }
        );
    }
96778
private void doInternalUndeployModule(final Message<JsonObject> message) {
    final String deploymentID = message.body().getString("id");
    if (deploymentID == null) {
      message.reply(new JsonObject().putString("status", "error").putString("message", "No deployment ID specified."));
    } else {
      removeDeployment(deploymentID, new Handler<AsyncResult<String>>() {
        @Override
        public void handle(AsyncResult<String> result) {
          platform.undeployModule(result.succeeded() && result.result() != null ? result.result() : deploymentID, createUndeployHandler(message));
        }
      });
    }
  }
256652
public static synchronized void deployment(Class<?> deployment) {
		Preconditions.checkArgument(deployment != null, 
				"Parameter 'deployment' must not be [" + deployment + "]");
		Preconditions.checkArgument(deployment.getAnnotation(Deployment.class) != null,
				"'deployment' [" + deployment + "] must be annotated with @Deployment");
		Jaguar.deployment = deployment;
		logger.info("Deployment has been set to [" + deployment.getSimpleName() + "]");
	}
281951
public ApplicationHostCache applicationHosts(long applicationId)
    {
        ApplicationHostCache cache = applicationHosts.get(applicationId);
        if(cache == null)
            applicationHosts.put(applicationId, cache = new ApplicationHostCache(applicationId));
        return cache;
    }
387522
public void deploy(InputStream inputStream) throws IOException {
        final List<? extends HasMetadata> entities = deploy("application", inputStream);

        if (this.applicationName == null) {

            Optional<String> deployment = entities.stream()
                .filter(hm -> hm instanceof Deployment)
                .map(hm -> (Deployment) hm)
                .map(rc -> rc.getMetadata().getName()).findFirst();

            deployment.ifPresent(name -> this.applicationName = name);
        }
    }
1163891
public void api_application_applicationId_DELETE(Long applicationId) throws IOException {
		String qPath = "/me/api/application/{applicationId}";
		StringBuilder sb = path(qPath, applicationId);
		exec(qPath, "DELETE", sb.toString(), null);
	}