/// <summary>
        /// Creates a dataflow job from a template.
        /// Documentation https://developers.google.com/dataflow/v1b3/reference/templates/create
        /// Generation Note: This does not always build corectly.  Google needs to standardise things I need to figuer out which ones are wrong.
        /// </summary>
        /// <param name="service">Authenticated dataflow service.</param>
        /// <param name="projectId">The project which owns the job.</param>
        /// <param name="body">A valid dataflow v1b3 body.</param>
        /// <returns>JobResponse</returns>
        public static Job Create(dataflowService service, string projectId, CreateJobFromTemplateRequest body)
        {
            try
            {
                // Initial validation.
                if (service == null)
                {
                    throw new ArgumentNullException("service");
                }
                if (body == null)
                {
                    throw new ArgumentNullException("body");
                }
                if (projectId == null)
                {
                    throw new ArgumentNullException(projectId);
                }

                // Make the request.
                return(service.Templates.Create(body, projectId).Execute());
            }
            catch (Exception ex)
            {
                throw new Exception("Request Templates.Create failed.", ex);
            }
        }
示例#2
0
 /// <summary>Snippet for CreateJobFromTemplate</summary>
 public void CreateJobFromTemplateRequestObject()
 {
     // Snippet: CreateJobFromTemplate(CreateJobFromTemplateRequest, CallSettings)
     // Create client
     TemplatesServiceClient templatesServiceClient = TemplatesServiceClient.Create();
     // Initialize request argument(s)
     CreateJobFromTemplateRequest request = new CreateJobFromTemplateRequest
     {
         ProjectId   = "",
         GcsPath     = "",
         Parameters  = { { "", "" }, },
         JobName     = "",
         Environment = new RuntimeEnvironment(),
         Location    = "",
     };
     // Make the request
     Job response = templatesServiceClient.CreateJobFromTemplate(request);
     // End snippet
 }
示例#3
0
        /// <summary>Snippet for CreateJobFromTemplateAsync</summary>
        public async Task CreateJobFromTemplateRequestObjectAsync()
        {
            // Snippet: CreateJobFromTemplateAsync(CreateJobFromTemplateRequest, CallSettings)
            // Additional: CreateJobFromTemplateAsync(CreateJobFromTemplateRequest, CancellationToken)
            // Create client
            TemplatesServiceClient templatesServiceClient = await TemplatesServiceClient.CreateAsync();

            // Initialize request argument(s)
            CreateJobFromTemplateRequest request = new CreateJobFromTemplateRequest
            {
                ProjectId   = "",
                GcsPath     = "",
                Parameters  = { { "", "" }, },
                JobName     = "",
                Environment = new RuntimeEnvironment(),
                Location    = "",
            };
            // Make the request
            Job response = await templatesServiceClient.CreateJobFromTemplateAsync(request);

            // End snippet
        }
        public void CreateJobFromTemplateRequestObject()
        {
            moq::Mock <TemplatesService.TemplatesServiceClient> mockGrpcClient = new moq::Mock <TemplatesService.TemplatesServiceClient>(moq::MockBehavior.Strict);
            CreateJobFromTemplateRequest request = new CreateJobFromTemplateRequest
            {
                ProjectId  = "project_id43ad98b0",
                GcsPath    = "gcs_path83b28bb9",
                Parameters =
                {
                    {
                        "key8a0b6e3c",
                        "value60c16320"
                    },
                },
                JobName     = "job_namedc176648",
                Environment = new RuntimeEnvironment(),
                Location    = "locatione09d18d5",
            };
            Job expectedResponse = new Job
            {
                Id                   = "id74b70bb8",
                ProjectId            = "project_id43ad98b0",
                Name                 = "name1c9368b0",
                Type                 = JobType.Unknown,
                Environment          = new Environment(),
                Steps                = { new Step(), },
                CurrentState         = JobState.Unknown,
                CurrentStateTime     = new wkt::Timestamp(),
                RequestedState       = JobState.Stopped,
                ExecutionInfo        = new JobExecutionInfo(),
                CreateTime           = new wkt::Timestamp(),
                ReplaceJobId         = "replace_job_id4a0fad7e",
                TransformNameMapping =
                {
                    {
                        "key8a0b6e3c",
                        "value60c16320"
                    },
                },
                ClientRequestId = "client_request_ide162ec50",
                ReplacedByJobId = "replaced_by_job_ida56afc22",
                TempFiles       =
                {
                    "temp_filescb023328",
                },
                Labels =
                {
                    {
                        "key8a0b6e3c",
                        "value60c16320"
                    },
                },
                Location            = "locatione09d18d5",
                PipelineDescription = new PipelineDescription(),
                StageStates         =
                {
                    new ExecutionStageState(),
                },
                JobMetadata           = new JobMetadata(),
                StartTime             = new wkt::Timestamp(),
                CreatedFromSnapshotId = "created_from_snapshot_id9b426c65",
                StepsLocation         = "steps_location41e078c5",
                SatisfiesPzs          = false,
            };

            mockGrpcClient.Setup(x => x.CreateJobFromTemplate(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
            TemplatesServiceClient client = new TemplatesServiceClientImpl(mockGrpcClient.Object, null);
            Job response = client.CreateJobFromTemplate(request);

            xunit::Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
 /// <summary>
 /// Creates a Cloud Dataflow job from a template.
 /// </summary>
 /// <param name="request">The request object containing all of the parameters for the API call.</param>
 /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
 /// <returns>A Task containing the RPC response.</returns>
 public override stt::Task <Job> CreateJobFromTemplateAsync(CreateJobFromTemplateRequest request, gaxgrpc::CallSettings callSettings = null)
 {
     Modify_CreateJobFromTemplateRequest(ref request, ref callSettings);
     return(_callCreateJobFromTemplate.Async(request, callSettings));
 }
 /// <summary>
 /// Creates a Cloud Dataflow job from a template.
 /// </summary>
 /// <param name="request">The request object containing all of the parameters for the API call.</param>
 /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
 /// <returns>The RPC response.</returns>
 public override Job CreateJobFromTemplate(CreateJobFromTemplateRequest request, gaxgrpc::CallSettings callSettings = null)
 {
     Modify_CreateJobFromTemplateRequest(ref request, ref callSettings);
     return(_callCreateJobFromTemplate.Sync(request, callSettings));
 }
 partial void Modify_CreateJobFromTemplateRequest(ref CreateJobFromTemplateRequest request, ref gaxgrpc::CallSettings settings);
 /// <summary>
 /// Creates a Cloud Dataflow job from a template.
 /// </summary>
 /// <param name="request">The request object containing all of the parameters for the API call.</param>
 /// <param name="cancellationToken">A <see cref="st::CancellationToken"/> to use for this RPC.</param>
 /// <returns>A Task containing the RPC response.</returns>
 public virtual stt::Task <Job> CreateJobFromTemplateAsync(CreateJobFromTemplateRequest request, st::CancellationToken cancellationToken) =>
 CreateJobFromTemplateAsync(request, gaxgrpc::CallSettings.FromCancellationToken(cancellationToken));
 /// <summary>
 /// Creates a Cloud Dataflow job from a template.
 /// </summary>
 /// <param name="request">The request object containing all of the parameters for the API call.</param>
 /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
 /// <returns>A Task containing the RPC response.</returns>
 public virtual stt::Task <Job> CreateJobFromTemplateAsync(CreateJobFromTemplateRequest request, gaxgrpc::CallSettings callSettings = null) =>
 throw new sys::NotImplementedException();
 /// <summary>
 /// Creates a Cloud Dataflow job from a template.
 /// </summary>
 /// <param name="request">The request object containing all of the parameters for the API call.</param>
 /// <param name="callSettings">If not null, applies overrides to this RPC call.</param>
 /// <returns>The RPC response.</returns>
 public virtual Job CreateJobFromTemplate(CreateJobFromTemplateRequest request, gaxgrpc::CallSettings callSettings = null) =>
 throw new sys::NotImplementedException();