/// <summary>Snippet for UpdateSink</summary>
 public void UpdateSink1()
 {
     // Snippet: UpdateSink(SinkNameOneof,LogSink,FieldMask,CallSettings)
     // Create client
     ConfigServiceV2Client configServiceV2Client = ConfigServiceV2Client.Create();
     // Initialize request argument(s)
     SinkNameOneof sinkName   = SinkNameOneof.From(new SinkName("[PROJECT]", "[SINK]"));
     LogSink       sink       = new LogSink();
     FieldMask     updateMask = new FieldMask();
     // Make the request
     LogSink response = configServiceV2Client.UpdateSink(sinkName, sink, updateMask);
     // End snippet
 }
        public async Task GetSinkAsync()
        {
            // Snippet: GetSinkAsync(string,CallSettings)
            // Additional: GetSinkAsync(string,CancellationToken)
            // Create client
            ConfigServiceV2Client configServiceV2Client = ConfigServiceV2Client.Create();
            // Initialize request argument(s)
            string formattedSinkName = ConfigServiceV2Client.FormatSinkName("[PROJECT]", "[SINK]");
            // Make the request
            LogSink response = await configServiceV2Client.GetSinkAsync(formattedSinkName);

            // End snippet
        }
        public async Task CreateSinkAsync()
        {
            // Snippet: CreateSinkAsync(string,LogSink,CallSettings)
            // Additional: CreateSinkAsync(string,LogSink,CancellationToken)
            // Create client
            ConfigServiceV2Client configServiceV2Client = ConfigServiceV2Client.Create();
            // Initialize request argument(s)
            string  formattedParent = ConfigServiceV2Client.FormatParentName("[PROJECT]");
            LogSink sink            = new LogSink();
            // Make the request
            LogSink response = await configServiceV2Client.CreateSinkAsync(formattedParent, sink);

            // End snippet
        }
        /// <summary>Snippet for GetSinkAsync</summary>
        public async Task GetSinkAsync()
        {
            // Snippet: GetSinkAsync(SinkNameOneof,CallSettings)
            // Additional: GetSinkAsync(SinkNameOneof,CancellationToken)
            // Create client
            ConfigServiceV2Client configServiceV2Client = await ConfigServiceV2Client.CreateAsync();

            // Initialize request argument(s)
            SinkNameOneof sinkName = SinkNameOneof.From(new SinkName("[PROJECT]", "[SINK]"));
            // Make the request
            LogSink response = await configServiceV2Client.GetSinkAsync(sinkName);

            // End snippet
        }
 /// <summary>Snippet for GetSink</summary>
 public void GetSink_RequestObject()
 {
     // Snippet: GetSink(GetSinkRequest,CallSettings)
     // Create client
     ConfigServiceV2Client configServiceV2Client = ConfigServiceV2Client.Create();
     // Initialize request argument(s)
     GetSinkRequest request = new GetSinkRequest
     {
         SinkNameAsSinkNameOneof = SinkNameOneof.From(new SinkName("[PROJECT]", "[SINK]")),
     };
     // Make the request
     LogSink response = configServiceV2Client.GetSink(request);
     // End snippet
 }
        /// <summary>Snippet for CreateSinkAsync</summary>
        public async Task CreateSinkAsync()
        {
            // Snippet: CreateSinkAsync(ParentNameOneof,LogSink,CallSettings)
            // Additional: CreateSinkAsync(ParentNameOneof,LogSink,CancellationToken)
            // Create client
            ConfigServiceV2Client configServiceV2Client = await ConfigServiceV2Client.CreateAsync();

            // Initialize request argument(s)
            ParentNameOneof parent = ParentNameOneof.From(new ProjectName("[PROJECT]"));
            LogSink         sink   = new LogSink();
            // Make the request
            LogSink response = await configServiceV2Client.CreateSinkAsync(parent, sink);

            // End snippet
        }
 /// <summary>Snippet for CreateSink</summary>
 public void CreateSink_RequestObject()
 {
     // Snippet: CreateSink(CreateSinkRequest,CallSettings)
     // Create client
     ConfigServiceV2Client configServiceV2Client = ConfigServiceV2Client.Create();
     // Initialize request argument(s)
     CreateSinkRequest request = new CreateSinkRequest
     {
         ParentAsParentNameOneof = ParentNameOneof.From(new ProjectName("[PROJECT]")),
         Sink = new LogSink(),
     };
     // Make the request
     LogSink response = configServiceV2Client.CreateSink(request);
     // End snippet
 }
        /// <summary>Snippet for UpdateSinkAsync</summary>
        public async Task UpdateSinkAsync1()
        {
            // Snippet: UpdateSinkAsync(SinkNameOneof,LogSink,FieldMask,CallSettings)
            // Additional: UpdateSinkAsync(SinkNameOneof,LogSink,FieldMask,CancellationToken)
            // Create client
            ConfigServiceV2Client configServiceV2Client = await ConfigServiceV2Client.CreateAsync();

            // Initialize request argument(s)
            SinkNameOneof sinkName   = SinkNameOneof.From(new SinkName("[PROJECT]", "[SINK]"));
            LogSink       sink       = new LogSink();
            FieldMask     updateMask = new FieldMask();
            // Make the request
            LogSink response = await configServiceV2Client.UpdateSinkAsync(sinkName, sink, updateMask);

            // End snippet
        }
        /// <summary>Snippet for GetSinkAsync</summary>
        public async Task GetSinkAsync_RequestObject()
        {
            // Snippet: GetSinkAsync(GetSinkRequest,CallSettings)
            // Additional: GetSinkAsync(GetSinkRequest,CancellationToken)
            // Create client
            ConfigServiceV2Client configServiceV2Client = await ConfigServiceV2Client.CreateAsync();

            // Initialize request argument(s)
            GetSinkRequest request = new GetSinkRequest
            {
                SinkNameAsSinkNameOneof = SinkNameOneof.From(new SinkName("[PROJECT]", "[SINK]")),
            };
            // Make the request
            LogSink response = await configServiceV2Client.GetSinkAsync(request);

            // End snippet
        }
        /// <summary>Snippet for UpdateSinkAsync</summary>
        public async Task UpdateSinkAsync_RequestObject()
        {
            // Snippet: UpdateSinkAsync(UpdateSinkRequest,CallSettings)
            // Create client
            ConfigServiceV2Client configServiceV2Client = await ConfigServiceV2Client.CreateAsync();

            // Initialize request argument(s)
            UpdateSinkRequest request = new UpdateSinkRequest
            {
                SinkNameAsSinkNameOneof = SinkNameOneof.From(new SinkName("[PROJECT]", "[SINK]")),
                Sink = new LogSink(),
            };
            // Make the request
            LogSink response = await configServiceV2Client.UpdateSinkAsync(request);

            // End snippet
        }
        /// <summary>Snippet for CreateSinkAsync</summary>
        public async Task CreateSinkAsync_RequestObject()
        {
            // Snippet: CreateSinkAsync(CreateSinkRequest,CallSettings)
            // Additional: CreateSinkAsync(CreateSinkRequest,CancellationToken)
            // Create client
            ConfigServiceV2Client configServiceV2Client = await ConfigServiceV2Client.CreateAsync();

            // Initialize request argument(s)
            CreateSinkRequest request = new CreateSinkRequest
            {
                ParentAsParentNameOneof = ParentNameOneof.From(new ProjectName("[PROJECT]")),
                Sink = new LogSink(),
            };
            // Make the request
            LogSink response = await configServiceV2Client.CreateSinkAsync(request);

            // End snippet
        }
示例#12
0
        // true if the process ran successfully
        public override bool ProcessTask()
        {
            string num = string.Empty;

            if (parameters.ContainsKey("num"))
            {
                num = parameters?["num"];
            }

            Random random       = new Random((int)DateTime.Now.Ticks & 0x0000FFFF);
            int    randomNumber = random.Next(5, 20);

            LogSink.Write(LogEntry.Entry($"TASK: Processing {Name}\t{randomNumber}\t{num}\r\n"));

            Thread.Sleep(3000);

            NextProcessTimeUTC = DateTime.UtcNow.AddSeconds(randomNumber);
            return(true);
        }
示例#13
0
        public void Run <TMainViewModel>()
        {
            IConfiguration configuration = _configurationBuilder.Build();

            LoggerConfiguration loggerConfiguration = new LoggerConfiguration()
                                                      .ReadFrom.Configuration(configuration);

            RegisterViewAssembly <BlasticApplication>();

            Configure(x => x.RegisterInstance(configuration));
            Configure(x => x.RegisterType <TMainViewModel>());

            _containerBuilder.Populate(_serviceCollection);
            IContainer container = _containerBuilder.Build();

            LogSink logSink = container.ResolveOptional <LogSink>();

            if (logSink != null)
            {
                loggerConfiguration.WriteTo.Sink(logSink);
            }

            Log.Logger = loggerConfiguration.CreateLogger();

            Bootstrapper bootstrapper = new Bootstrapper(
                container,
                typeof(TMainViewModel),
                _viewAssemblies);

            SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext());

            try
            {
                bootstrapper.Initialize();
                _application.Run();
            }
            catch (Exception exception)
            {
                Log.Error(exception, exception.Message);
                throw;
            }
        }
示例#14
0
        // [END list_log_entries]

        // [START create_log_sink]
        private void CreateSink(string sinkId, string logId)
        {
            var sinkClient = ConfigServiceV2Client.Create();
            CreateSinkRequest sinkRequest = new CreateSinkRequest();
            LogSink           myLogSink   = new LogSink();
            string            sinkName    = $"projects/{s_projectId}/sinks/{sinkId}";

            myLogSink.Name = sinkId;

            // This creates a sink using a Google Cloud Storage bucket
            // named the same as the projectId.
            // This requires editing the bucket's permissions to add the Entity Group
            // named '*****@*****.**' with 'Owner' access for the bucket.
            // If this is being run with a Google Cloud service account,
            // that account will need to be granted 'Owner' access to the Project.
            myLogSink.Destination = "storage.googleapis.com/" + s_projectId;
            string logName = $"projects/{s_projectId}/logs/{logId}";

            myLogSink.Filter   = $"logName={logName}AND severity<=ERROR";
            sinkRequest.Parent = $"projects/{s_projectId}";
            sinkRequest.Sink   = myLogSink;
            sinkClient.CreateSink(sinkRequest.Parent, myLogSink);
            _out.WriteLine($"Created sink: {sinkId}.");
        }
示例#15
0
        public void GetSink2()
        {
            Mock <ConfigServiceV2.ConfigServiceV2Client> mockGrpcClient = new Mock <ConfigServiceV2.ConfigServiceV2Client>(MockBehavior.Strict);
            GetSinkRequest request = new GetSinkRequest
            {
                SinkNameAsSinkNameOneof = SinkNameOneof.From(new SinkName("[PROJECT]", "[SINK]")),
            };
            LogSink expectedResponse = new LogSink
            {
                Name = "name3373707",
                DestinationAsResourceName = new BillingName("[BILLING_ACCOUNT]"),
                Filter          = "filter-1274492040",
                WriterIdentity  = "writerIdentity775638794",
                IncludeChildren = true,
            };

            mockGrpcClient.Setup(x => x.GetSink(request, It.IsAny <CallOptions>()))
            .Returns(expectedResponse);
            ConfigServiceV2Client client = new ConfigServiceV2ClientImpl(mockGrpcClient.Object, null);
            LogSink response             = client.GetSink(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
示例#16
0
        public async Task GetSinkAsync2()
        {
            Mock <ConfigServiceV2.ConfigServiceV2Client> mockGrpcClient = new Mock <ConfigServiceV2.ConfigServiceV2Client>(MockBehavior.Strict);
            GetSinkRequest request = new GetSinkRequest
            {
                SinkNameAsSinkNameOneof = SinkNameOneof.From(new SinkName("[PROJECT]", "[SINK]")),
            };
            LogSink expectedResponse = new LogSink
            {
                Name = "name3373707",
                DestinationAsResourceName = new ProjectName("[PROJECT]"),
                Filter          = "filter-1274492040",
                WriterIdentity  = "writerIdentity775638794",
                IncludeChildren = true,
            };

            mockGrpcClient.Setup(x => x.GetSinkAsync(request, It.IsAny <CallOptions>()))
            .Returns(new Grpc.Core.AsyncUnaryCall <LogSink>(Task.FromResult(expectedResponse), null, null, null, null));
            ConfigServiceV2Client client = new ConfigServiceV2ClientImpl(mockGrpcClient.Object, null);
            LogSink response             = await client.GetSinkAsync(request);

            Assert.Same(expectedResponse, response);
            mockGrpcClient.VerifyAll();
        }
        protected override LoggingBaseServiceRequest <LogSink> GetRequest(LogSink logSink)
        {
            string formattedSinkName = PrefixProjectToSinkName(SinkName, Project);

            // If destinations are not given, we still have to set the destination to the existing log sink destination.
            // Otherwise, the API will throw error.
            if (GcsBucketDestination == null && BigQueryDataSetDestination == null && PubSubTopicDestination == null)
            {
                try
                {
                    ProjectsResource.SinksResource.GetRequest getRequest = Service.Projects.Sinks.Get(formattedSinkName);
                    LogSink existingSink = getRequest.Execute();
                    logSink.Destination = existingSink.Destination;
                }
                catch (GoogleApiException ex) when(ex.HttpStatusCode == HttpStatusCode.NotFound)
                {
                    // Here we throw terminating error because the cmdlet cannot proceed without a valid sink.
                    string exceptionMessage = $"Sink '{SinkName}' does not exist in project '{Project}'." +
                                              "Please use New-GcLogSink cmdlet to create it (Set-GcLogSink can only create a sink if you supply a destination).";
                    ErrorRecord errorRecord = new ErrorRecord(
                        new ArgumentException(exceptionMessage),
                        "SinkNotFound",
                        ErrorCategory.ResourceUnavailable,
                        SinkName);

                    ThrowTerminatingError(errorRecord);
                }
            }

            ProjectsResource.SinksResource.UpdateRequest updateRequest = Service.Projects.Sinks.Update(logSink, formattedSinkName);
            if (UniqueWriterIdentity.IsPresent)
            {
                updateRequest.UniqueWriterIdentity = UniqueWriterIdentity.ToBool();
            }
            return(updateRequest);
        }
示例#18
0
 public LogSinkTraceLogger(LogSink sink)
 {
     this.sink = sink;
 }
示例#19
0
        public static void SendTestMessage(LogSink sink)
        {
            LogEntry logEntry = CommonUtil.GetDefaultLogEntry();

            sink.SendMessage(logEntry);
        }
示例#20
0
 private void Main()
 {
     while (thread.ThreadState != ThreadState.AbortRequested)
        {
     Task task = null;
     lock (tasksLock)
     {
      while (scheduledTasks.Count != 0)
       if (scheduledTasks.Values[0].Count == 0)
       {
        scheduledTasks.RemoveAt(0);
       }
       else
       {
        if (scheduledTasks.Keys[0] <= DateTime.Now)
        {
     List<Task> tasks = scheduledTasks.Values[0];
     task = tasks[0];
     tasks.RemoveAt(0);
        }
        if (task == null)
        {
     for (int i = 0; i < scheduledTasks.Count; )
      if (scheduledTasks.Values[i].Count == 0)
       scheduledTasks.RemoveAt(i);
      else
       ++i;
        }
        break;
       }
     }
     if (task != null)
     {
      LogSink sessionLog = new LogSink();
      task.Log.Add(sessionLog);
      using (new LogSession(sessionLog))
      {
       ExecuteTask(task);
      }
     }
     schedulerInterrupt.WaitOne(30000, false);
        }
 }
示例#21
0
        /// <summary>
        /// The thread entry point for this object. This object operates on a queue
        /// and hence the thread will sequentially execute tasks.
        /// </summary>
        private void Main()
        {
            //The waiting thread will utilize a polling loop to check for new
            //scheduled tasks. This will be checked every 30 seconds. However,
            //when the thread is waiting for a new task, it can be interrupted.
            while (thread.ThreadState != ThreadState.AbortRequested)
            {
                //Check for a new task
                Task task = null;
                lock (tasksLock)
                {
                    while (scheduledTasks.Count != 0)
                    {
                        if (scheduledTasks.Values[0].Count == 0)
                        {
                            //Clean all all time slots at the start of the queue which are
                            //empty
                            scheduledTasks.RemoveAt(0);
                        }
                        else
                        {
                            if (scheduledTasks.Keys[0] <= DateTime.Now)
                            {
                                List <Task> tasks = scheduledTasks.Values[0];
                                task = tasks[0];
                                tasks.RemoveAt(0);
                            }

                            //Do schedule queue maintenance: clean up all empty timeslots
                            if (task == null)
                            {
                                for (int i = 0; i < scheduledTasks.Count;)
                                {
                                    if (scheduledTasks.Values[i].Count == 0)
                                    {
                                        scheduledTasks.RemoveAt(i);
                                    }
                                    else
                                    {
                                        ++i;
                                    }
                                }
                            }

                            break;
                        }
                    }
                }

                if (task != null)
                {
                    LogSink sessionLog = new LogSink();
                    task.Log.Add(sessionLog);

                    //Start a new log session to separate this session's events
                    //from previous ones.
                    try
                    {
                        using (new LogSession(sessionLog))
                        {
                            //Set the currently executing task.
                            currentTask = task;

                            //Prevent the system from sleeping.
                            Power.ExecutionState = ExecutionState.Continuous |
                                                   ExecutionState.SystemRequired;

                            task.Execute();
                        }
                    }
                    finally
                    {
                        //Allow the system to sleep again.
                        Power.ExecutionState = ExecutionState.Continuous;

                        //If the task is a recurring task, reschedule it for the next execution
                        //time since we are done with this one.
                        if (task.Schedule is RecurringSchedule)
                        {
                            ScheduleTask(task);
                        }

                        //If the task is an execute on restart task or run immediately task, it is
                        //only run once and can now be restored to a manually run task
                        else if (task.Schedule == Schedule.RunOnRestart ||
                                 task.Schedule == Schedule.RunNow)
                        {
                            task.Schedule = Schedule.RunManually;
                        }

                        //Remove the actively executing task from our instance variable
                        currentTask = null;
                    }
                }

                //Wait for half a minute to check for the next scheduled task.
                schedulerInterrupt.WaitOne(30000, false);
            }
        }
示例#22
0
 public DetailsModel(LogSink logger, ContentContext dbContext)
 {
     this.Logger    = logger;
     this.DbContext = dbContext;
 }
        // [END list_log_entries]
        // [START create_log_sink]
        private void CreateSink(string sinkId, string logId)
        {
            var sinkClient = ConfigServiceV2Client.Create();
            CreateSinkRequest sinkRequest = new CreateSinkRequest();
            LogSink myLogSink = new LogSink();
            myLogSink.Name = sinkId;

            // This creates a sink using a Google Cloud Storage bucket
            // named the same as the projectId.
            // This requires editing the bucket's permissions to add the Entity Group
            // named '*****@*****.**' with 'Owner' access for the bucket.
            // If this is being run with a Google Cloud service account,
            // that account will need to be granted 'Owner' access to the Project.
            // In Powershell, use this command:
            // PS > Add-GcsBucketAcl <your-bucket-name> -Role OWNER -Group [email protected]
            myLogSink.Destination = "storage.googleapis.com/" + s_projectId;
            LogName logName = new LogName(s_projectId, logId);
            myLogSink.Filter = $"logName={logName.ToString()}AND severity<=ERROR";
            ProjectName projectName = new ProjectName(s_projectId);
            sinkRequest.Sink = myLogSink;
            sinkClient.CreateSink(ParentNameOneof.From(projectName), myLogSink, RetryAWhile);
            Console.WriteLine($"Created sink: {sinkId}.");
        }
示例#24
0
 public FullOwnershipContentContext(
     LogSink securityLog, ContentContext context, TenancyProvider tenancyProvider)
     : base(securityLog, context, tenancyProvider)
 {
 }
 public ContentContext(DbContextOptions <ContentContext> options, LogSink logger) : base(options)
 {
     this.Logger = logger;
 }
 /// <summary>
 /// Given a log sink, returns either a create or update request that will be used by the cmdlet.
 /// </summary>
 protected abstract LoggingBaseServiceRequest <LogSink> GetRequest(LogSink logsink);
        protected override void ProcessRecord()
        {
            LogSink logSink = new LogSink()
            {
                Name = SinkName
            };

            string permissionRequest = "";

            switch (ParameterSetName)
            {
            case ParameterSetNames.GcsBucketDestination:
                logSink.Destination = $"storage.googleapis.com/{GcsBucketDestination}";
                permissionRequest   = $"'Owner' permission to the bucket '{GcsBucketDestination}'.";
                break;

            case ParameterSetNames.BigQueryDataSetDestination:
                logSink.Destination = $"bigquery.googleapis.com/projects/{Project}/datasets/{BigQueryDataSetDestination}";
                permissionRequest   = $"'Can edit' permission to the dataset '{BigQueryDataSetDestination}'.";
                break;

            case ParameterSetNames.PubSubTopicDestination:
                logSink.Destination = $"pubsub.googleapis.com/projects/{Project}/topics/{PubSubTopicDestination}";
                permissionRequest   = $"'Editor' permission in the project '{Project}'.";
                break;
            }

            string logName = PrefixProjectToLogName(LogName, Project);

            // The sink already has before and after filter so we do not have to supply it.
            logSink.Filter = ConstructLogFilterString(
                logName: logName,
                logSeverity: Severity,
                selectedType: SelectedResourceType,
                before: null,
                after: null,
                otherFilter: Filter);

            if (Before.HasValue)
            {
                logSink.EndTime = XmlConvert.ToString(Before.Value, XmlDateTimeSerializationMode.Local);
            }

            if (After.HasValue)
            {
                logSink.StartTime = XmlConvert.ToString(After.Value, XmlDateTimeSerializationMode.Local);
            }

            LoggingBaseServiceRequest <LogSink> request = GetRequest(logSink);

            try
            {
                LogSink createdSink = request.Execute();
                WriteObject(createdSink);
                // We want to let the user knows that they have to grant appropriate permission to the writer identity
                // so that the logs can be exported (otherwise, the export will fail).
                Host.UI.WriteLine($"Please remember to grant '{createdSink?.WriterIdentity}' {permissionRequest}");
            }
            catch (GoogleApiException ex) when(ex.HttpStatusCode == HttpStatusCode.Conflict)
            {
                WriteResourceExistsError(
                    exceptionMessage: $"Cannot create '{SinkName}' in project '{Project}' because it already exists.",
                    errorId: "SinkAlreadyExists",
                    targetObject: LogName);
            }
        }
示例#28
0
 public void Add(LogSink sink)
 {
     writers_.Add(sink);
 }
示例#29
0
 public AssignedContentReadingContext(
     LogSink securityLog, ContentContext context, TenancyProvider tenancyProvider)
     : base(securityLog, context, tenancyProvider)
 {
 }
示例#30
0
 public ApplicationLogViewModel(LogSink logSink)
 {
     this.logSink             = logSink;
     Logs                     = new ObservableList <string>(logSink.Events);
     logSink.LogEventEmitted += EventSink_LogEventEmitted;
 }
示例#31
0
 public IndexModel(LogSink logger, ContentContext dbContext)
 {
     this.Logger    = logger;
     this.DbContext = dbContext;
 }
示例#32
0
 public static bool IsCloudStorageSink(this LogSink sink)
 {
     return(sink.Destination.StartsWith(CloudStorageDestinationPrefix));
 }