private async Task PlaySong(YoutubeExplode.Videos.Video input)
{
try
{
await audioClient.SetSpeakingAsync(true);
var streamManifest = await youtube.Videos.Streams.GetManifestAsync(input.Id, Skip.Token);
var streamInfo = streamManifest.GetAudioOnlyStreams().GetWithHighestBitrate();
var stream = await youtube.Videos.Streams.GetAsync(streamInfo, Skip.Token);
var memoryStream = new MemoryStream();
await Cli.Wrap("ffmpeg")
.WithArguments(" -hide_banner -loglevel panic -i pipe:0 -ac 2 -f s16le -ar 48000 pipe:1")
.WithStandardInputPipe(PipeSource.FromStream(stream))
.WithStandardOutputPipe(PipeTarget.ToStream(memoryStream))
.ExecuteAsync(Skip.Token);
using (var discord = audioClient.CreatePCMStream(AudioApplication.Music))
{
try { await discord.WriteAsync(memoryStream.ToArray(), 0, (int)memoryStream.Length, Skip.Token); }
finally { await discord.FlushAsync(); }
}
}
catch (Exception)
{
}
}
internal static async Task ExecuteInternal(Action <ArgumentsBuilder> configure, CancellationToken cancellationToken)
{
ThrowIfNull(ToolPath, nameof(SdkManager));
var stdErrBuffer = new StringBuilder();
await Cli.Wrap(ToolPath)
.WithArguments(configure)
.WithValidation(CommandResultValidation.None)
.WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErrBuffer))
.WithStandardOutputPipe(PipeTarget.ToDelegate(l => Logger.WriteLine(l, LogLevel.Detailed)))
.WithStandardInputPipe(PipeSource.FromString("y"))
.ExecuteAsync(cancellationToken);
var stdErr = stdErrBuffer.ToString().Trim();
if (!string.IsNullOrEmpty(stdErr))
{
if (stdErr.Split('\n').Select(x => x.Trim()).All(x => x.StartsWith("Warning:")))
{
Logger.WriteWarning(stdErr);
}
else
{
throw new Exception(stdErr);
}
}
}
public static async Task InstallEmulator(string emulatorName, int sdkVersion, CancellationToken cancellationToken)
{
var devices = await GetDevices(cancellationToken);
var device = devices
.Where(x => Regex.IsMatch(x, @"^pixel_\d$"))
.OrderByDescending(x => x)
.FirstOrDefault();
if (string.IsNullOrEmpty(device))
{
Logger.WriteError("Current Devices");
foreach (var d in devices)
{
Logger.WriteError($" - {d}");
}
throw new Exception("No pixel device found.");
}
Logger.WriteLine($"Installing Emulator for SDK Version: {sdkVersion} with Device {device}", LogLevel.Normal);
await ExecuteInternal(b =>
{
b.Add("create")
.Add("avd")
.Add("--name")
.Add(emulatorName)
.Add("--package")
.Add($"system-images;android-{sdkVersion};google_apis_playstore;x86")
.Add("--device")
.Add(device)
.Add("--force");
}, cancellationToken, PipeSource.FromString("no")).ConfigureAwait(false);
}
private async void StartStream(YoutubeClient youtube, AudioClient audioClient, AudioOnlyStreamInfo streamInfo, IMessage?message)
{
Stream ytStream = await youtube.Videos.Streams.GetAsync(streamInfo);
// Convert yt stream
MemoryStream memoryStream = new MemoryStream();
await Cli.Wrap("ffmpeg")
.WithArguments(" -hide_banner -loglevel panic -i pipe:0 -ac 2 -f s16le -ar 48000 pipe:1")
.WithStandardInputPipe(PipeSource.FromStream(ytStream))
.WithStandardOutputPipe(PipeTarget.ToStream(memoryStream))
.ExecuteAsync();
// Clear stream before beginning
if (audioClient.CurrentStream != null)
{
audioClient.CurrentStream.Dispose();
audioClient.CurrentStream = null;
}
AudioOutStream discord = audioClient.Client.CreatePCMStream(AudioApplication.Mixed);
audioClient.CurrentStream = discord;
// Delete calling command
if (message != null)
{
await message.DeleteAsync();
}
// Start playing music
await this.WriteStreamToVoiceChannel(audioClient, discord, memoryStream);
}
public void ShouldExecuteTheCodeForThisNode()
{
var testSubject = new PipeSource <decimal, decimal>(_AddThree);
testSubject.Call(4);
_lastInputSeen.Should()
.Be(4);
}
public void ShouldDisplayBindGraph()
{
var testSubject = new PipeSource <decimal, int>(_One);
testSubject.AndThen(_Two).AndThen(new Collector <float>());
testSubject.AndThen <string>(_Three);
Approvals.Verify(testSubject);
}
public void CanGatherResultsEasily()
{
var testSubject = new PipeSource <decimal, decimal>(_AddThree);
var results = new Collector <decimal>();
testSubject.AndThen(results);
testSubject.Call(4);
results.Results.Should()
.BeEquivalentTo(7M);
}
public void SmokeTest()
{
var pipeline = new XmlPipeline();
pipeline
.Source(PipeSource.Files(new[] { Path.Combine(TestPath.InputTestFilesFolder, @"xml\test1.xml") }))
.Pipe(new XsdValidateTransform(Path.Combine(TestPath.InputTestFilesFolder, @"xsd\schema1.xsd")))
.Destination(PipeDestination.Folder(TestPath.OutputTestFilesFolder), s => s + "_out.xml")
.Pump(false);
}
public void I_can_create_a_new_command_from_an_existing_one_by_specifying_different_stdin_pipe()
{
// Arrange
var cmd = Cli.Wrap("foo").WithStandardInputPipe(PipeSource.Null);
// Act
var cmdOther = cmd.WithStandardInputPipe(PipeSource.FromString("new"));
// Assert
cmd.Should().BeEquivalentTo(cmdOther, o => o.Excluding(c => c.StandardInputPipe));
cmd.StandardInputPipe.Should().NotBeSameAs(cmdOther.StandardInputPipe);
}
public void Stdin_pipe_can_be_set()
{
// Arrange
var cmd = Cli.Wrap("foo").WithStandardInputPipe(PipeSource.Null);
// Act
var cmdOther = cmd.WithStandardInputPipe(PipeSource.FromString("new"));
// Assert
cmd.Should().BeEquivalentTo(cmdOther, o => o.Excluding(c => c.StandardInputPipe));
cmd.StandardInputPipe.Should().NotBeSameAs(cmdOther.StandardInputPipe);
}
public void ShouldSendTheResultToAnyListeners()
{
var testSubject = new PipeSource <decimal, decimal>(_AddThree);
using (var monitor = testSubject.Monitor())
{
testSubject.Call(4);
var expectation = new[] { Result(7), Done() };
monitor.OccurredEvents.Should()
.BeEquivalentTo(expectation, options => options.WithStrictOrdering()
.ExcludingMissingMembers());
}
}
public void ShouldAllowGeneratorFunctionsToPushSeveralArgumentsThenAutomaticallyFinishWhenTheyAreDone()
{
var testSubject = new PipeSource <decimal, decimal>(_AddOneTwoThree);
using (var monitor = testSubject.Monitor())
{
testSubject.Call(4);
var expectation = new[] { Result(5), Result(6), Result(7), Done() };
monitor.OccurredEvents.Should()
.BeEquivalentTo(expectation, options => options.WithStrictOrdering()
.ExcludingMissingMembers());
}
}
public void should_create_pipe()
{
var pipe = new FakePipe();
var containerMock = new Mock <IContainer>();
containerMock.Setup(x => x.GetInstance <FakePipe>()).Returns(pipe);
var source = new PipeSource <FakePipe>(containerMock.Object);
var pipes = source.GetPipes(typeof(FakeMessageHandler));
pipes.Single().ShouldEqual(pipe);
}
public void ShouldConnectThroughMultipleLayers()
{
var head = new PipeSource <decimal, decimal>(_AddThree);
var middle = head.AndThen(_AddThree);
using (var monitor = middle.Monitor())
{
head.Call(4);
var expectation = new[] { Result(10), Done() };
monitor.OccurredEvents.Should()
.BeEquivalentTo(expectation, options => options.WithStrictOrdering()
.ExcludingMissingMembers());
}
}
public void GatheringResultsRethrowsExceptions()
{
var testSubject = new PipeSource <decimal, decimal>(_ThowException);
var results = new Collector <decimal>();
testSubject.AndThen(results);
testSubject.Call(4);
results.Invoking(all =>
{
var r = all.Results;
})
.Should()
.Throw <AggregateException>()
.WithInnerException <ArgumentException>()
.WithMessage("The right one.");
}
private static async Task ExecuteInternal(Action <ArgumentsBuilder> configure, CancellationToken cancellationToken)
{
ThrowIfNull(ToolPath, nameof(SdkManager));
var stdErrBuffer = new StringBuilder();
await Cli.Wrap(ToolPath)
.WithArguments(configure)
.WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErrBuffer))
.WithStandardOutputPipe(PipeTarget.ToDelegate(l => Logger.WriteLine(l, LogLevel.Detailed)))
.WithStandardInputPipe(PipeSource.FromString("y"))
.ExecuteAsync(cancellationToken);
var stdErr = stdErrBuffer.ToString().Trim();
if (!string.IsNullOrEmpty(stdErr))
{
throw new Exception(stdErr);
}
}
public static async Task InstallEmulator(int sdkVersion, CancellationToken cancellationToken)
{
var devices = await GetDevices(cancellationToken);
var device = devices
.Where(x => Regex.IsMatch(x, @"^pixel_\d$"))
.OrderByDescending(x => x)
.FirstOrDefault();
Logger.WriteLine($"Installing Emulator for SDK Version: {sdkVersion} with Device {device}", LogLevel.Normal);
await ExecuteInternal(b =>
{
b.Add("create")
.Add("avd")
.Add($"-n {DefaultUITestEmulatorName}")
.Add($@"-k ""system-images;android-{sdkVersion};google_apis_playstore;x86""")
.Add($"--device {device}")
.Add("--force");
}, cancellationToken, PipeSource.FromString("no")).ConfigureAwait(false);
}
public static PipeSource <string, CharacterFile> CreatePipeline(out Collector <CharacterFile> characterTrap, out Collector <ConfigFile> configTrap,
out PipeMiddle <CharacterFile, ConfigFile> configFileNode, out Collector <CardData> partialCardsTrap, out Collector <CardData> localCardsTrap)
{
var orchestration = new PipeSource <string, CharacterFile>(CharacterFile.From);
characterTrap = new Collector <CharacterFile>();
orchestration.AndThen(characterTrap);
configFileNode = orchestration.AndThen(ConfigFile.Matching);
configTrap = new Collector <ConfigFile>();
configFileNode.AndThen(configTrap);
partialCardsTrap = new Collector <CardData>();
var partialCardFinder =
orchestration.AndThen(PipelineAdapter.Scatter <CharacterFile, CardData>(CharacterFile.GetTheCards));
partialCardFinder.AndThen(partialCardsTrap);
localCardsTrap = new Collector <CardData>();
var localCardFinder = configFileNode.AndThen(PipelineAdapter.Scatter <ConfigFile, CardData>(ConfigFile.GetTheCards));
localCardFinder.AndThen(localCardsTrap);
return(orchestration);
}
public async Task SendYTAudioAsync(IGuild guild, IMessageChannel channel, IVoiceChannel target, string path, double volume = 1.0)
{
volume *= 0.25;
CurrentAudioInformation client;
if (CurrentAudioClients.TryGetValue(guild.Id, out client))
{
await CheckAudioClient(guild, target, client.client);
string youtubeID = GetYouTubeVideoIdFromUrl(path);
if (youtubeID == null)
{
await channel.SendMessageAsync("That is not a valid youtube link!");
return;
}
if (!string.IsNullOrEmpty(client.playing))
{
client.queue.Enqueue(path);
await channel.SendMessageAsync($"Added {path} to the queue.");
return;
}
client.playing = path;
await _log.LogAsync(new LogMessage(LogSeverity.Info, "Audio", $"Starting playback of {path} in {guild.Name}"));
if (client.currentStream == null)
{
client.currentStream = client.client.CreatePCMStream(AudioApplication.Mixed, 98304, 200);
}
var youtube = new YoutubeClient();
var streamManifest = await youtube.Videos.Streams.GetManifestAsync(youtubeID);
var streamInfo = streamManifest.GetAudioOnlyStreams().GetWithHighestBitrate();
var memoryStream = new MemoryStream();
var video = await youtube.Videos.Streams.GetAsync(streamInfo);
await Cli.Wrap("ffmpeg")
.WithArguments($"-hide_banner -loglevel panic -i pipe:0 -filter:a \"volume = {volume}\" -ac 2 -f s16le -ar 48000 pipe:1")
.WithStandardInputPipe(PipeSource.FromStream(video))
.WithStandardOutputPipe(PipeTarget.ToStream(memoryStream))
.ExecuteAsync();
try {
client.cancelTokenSource = new CancellationTokenSource();
await client.currentStream.WriteAsync(memoryStream.ToArray(), 0, (int)memoryStream.Length, client.cancelTokenSource.Token);
} catch (OperationCanceledException e) {
await channel.SendMessageAsync($"Stopped http://youtu.be/{youtubeID}");
} finally {
await _log.LogAsync(new LogMessage(LogSeverity.Verbose, "Audio", $"Finished playing {path}."));
await CheckQueue(guild, channel, target);
}
}
else
{
await JoinAudio(guild, target);
await SendYTAudioAsync(guild, channel, target, path, volume);
}
}
private static async Task <string> ExecuteInternal(Action <ArgumentsBuilder> configure, CancellationToken cancellationToken, PipeSource stdInput = null)
{
var toolPath = ToolPath;
ThrowIfNull(toolPath, nameof(AvdManager));
var builder = new ArgumentsBuilder();
configure(builder);
var args = builder.Build();
Logger.WriteLine($"{toolPath} {args}", LogLevel.Normal);
var stdErrBuffer = new StringBuilder();
var stdOutBuffer = new StringBuilder();
var stdOut = PipeTarget.Merge(PipeTarget.ToStringBuilder(stdOutBuffer),
PipeTarget.ToDelegate(l => Logger.WriteLine(l, LogLevel.Verbose)));
var cmd = Cli.Wrap(toolPath)
.WithArguments(args)
.WithStandardErrorPipe(PipeTarget.ToStringBuilder(stdErrBuffer))
.WithStandardOutputPipe(stdOut);
if (stdInput != null)
{
cmd = cmd.WithStandardInputPipe(stdInput);
}
await cmd.ExecuteAsync(cancellationToken);
var stdErr = stdErrBuffer.ToString().Trim();
if (!string.IsNullOrEmpty(stdErr))
{
throw new Exception(stdErr);
}
return(stdOutBuffer.ToString().Trim());
}
private static async Task <string> ExecuteInternal(Action <ArgumentsBuilder> configure, CancellationToken cancellationToken, PipeSource stdInput = null)
{
var toolPath = ToolPath;
ThrowIfNull(toolPath, nameof(AvdManager));
var builder = new ArgumentsBuilder();
configure(builder);
var args = builder.Build();
Logger.WriteLine($"{toolPath} {args}", LogLevel.Normal);
var errorBuffer = new List <string>();
var stdOutBuffer = new StringBuilder();
var stdOut = PipeTarget.Merge(PipeTarget.ToStringBuilder(stdOutBuffer),
PipeTarget.ToDelegate(l => Logger.WriteLine(l, LogLevel.Verbose)));
var stdErr = PipeTarget.ToDelegate(l =>
{
if (string.IsNullOrEmpty(l))
{
return;
}
else if (l.Contains("Warning: "))
{
Logger.WriteWarning(l);
}
else
{
errorBuffer.Add(l);
}
});
var cmd = Cli.Wrap(toolPath)
.WithArguments(args)
.WithValidation(CommandResultValidation.None)
.WithStandardErrorPipe(stdErr)
.WithStandardOutputPipe(stdOut);
if (stdInput != null)
{
cmd = cmd.WithStandardInputPipe(stdInput);
}
await cmd.ExecuteAsync(cancellationToken);
if (errorBuffer.Any())
{
throw new Exception(string.Join(Environment.NewLine, errorBuffer));
}
return(stdOutBuffer.ToString().Trim());
}