Add initial tests for Group and Group.prototype.child

Description of the problem this pull request fixes
There were no tests for Group, and Group.child is instrumental to adding new marks. This PR begins to flesh out test coverage for the Group mark, starting with Group.prototype.child.

You have text mark code in this. Do you want the tests to be separate from that?

@deathbearbrown whoops forgot it was the same branch :D will rebase

@deathbearbrown Removed the non-PR-related commits

+1 to merge after travis runs


release commits are not tagged

It would really be useful for those of us that prefer to pull from github and build locally if release commits were tagged.

Future releases will be tagged.  We will not be retroactively creating tags for old releases


Detailed documentations and Tutorial

Hello,
Can you provide more detailed documentation? The code cannot be run at this time.
Best Regards,

you can find  some docs in https://moss.fiblab.net/docs/introduction
Now we find some bugs to avoid running correctly.
The key is that you should always set enable_output=True when initializing Engine


add moment-to-date helper

Via moment.js to() function

Thanks!

You're welcome, but seems I forgot to change README and mention this helper

Please do in another PR, I haven't versioned yet


feat(imagestreamtags): add resource

Needed to add ImageTag resource for our pruning script

@tavogel cool,  i'll review today. Thanks!

@tavogel released as 1.5.0

@tavogel also wanted to let you know, we are changing the GH org name to nodeshift, so i'll be moving this repo soon,  but GH should take care of the routing


chore(dice): Fully refactored dice mechinics and tests

This PR refactors the dice mechanics fully, including the tests. There is some room for work on the rendering of chat cards & dialogs, especially testing them. But this should solidify the dice mechanics and make them more modular.
e.g. RollSD.Roll(parts, data, $form, adv, options) is the goto for any non-D20 roll from a sheet, and RollSD.RollD20(parts, data, $form, adv, options) is for d20 rolls (which also checks the special cases like spell rolling and weapons). See RollSD.Roll documentation for what you can configure.

There's some conflicts to resolve after I merged your other pull request.

There we go, conflicts solved and all tests are green!


Add bindings for ardupilotmega.xml

This patch adds bindings for messages defined in ardupilotmega.xml. XML data was manually copied and pasted into combined.xml - perhaps this could be automated in the future.

Been testing it with Arducopter software-in-the-loop: seems to be detecting the new messages appropriately.

Probably obsolete, as it is trivial to add additional xml files to parse, but it is unclear whether it is something we should do.

Hi @podhrmic The general model for all our other generators is that they take mavlink version and one or more dialects as inputs, and generate libraries for the specified dialect.
For pre-built versions the model (at least for C and Python) is to generate libraries for all dialects in mavlink/mavlink and include them in the package.
While I don't understand what this code is doing, I suggest you try emulate that approach.

This PR is covered by #40, consider closing it when 40 is merged? @patrickelectric


Networks - support firewall rules and ports

Allow to define firewall rules and filtering of ports for all the supported IaaS controllers:

AWS controller

OpenStack controller

VMware controller

Needs to include Azure ARM and K5

This should be linked to security groups, so you set rules for groups & then add resources to the groups.  Not directly to the resources as it is bad practise.

visualisation like this would be a very useful feature: http://docs.rightscale.com/img/cm-network-map-example.png

Don't block any setting, it should be user configurable and if they want "everything open" then they should be able to set it.  perhaps it is useful for a development environment.
It would be good to have a warning or link to security best practise guidelines when they are in this section so that we can provide them with guidance, but not with restrictions.

This feature should be accessible via APIs and the GUI

When applying "everything open", there may be some restrictions on the usage due to security policy.
The default setting should be selective either from "everything open" or "All denied".

The support for firewall rules can be done for the AWS and the OpenStack controllers.
A K5 controller is not yet part of OSCM, but it is planned for release 16.2.
An Azure controller is not part of OSCM, but you are free to contribute such a controller.


Broken / wrong links when no paid plan is configured

Issue Summary
As a new Ghost publisher, I'm not ready to connect to Stripe and configure the paid plans for members. I'm starting out with simple free sign-up.
Several UI bugs occur for site visitors in this state. When a signed-in visitor visits the site and there are no configured paid plans,

In some themes, they get Upgrade buttons which display a broken dialog (Journal v1.0.0).
They still see Sign up links (although signed up and logged in) Casper v5.3.1 and Journal v1.0.0 and probably others.

Here, a signed-in member is incorrectly shown the upgrade button in multiple places leading to a broken dialog (Journal v1.0.0 theme):

Broken dialog:

Here, a signed-up and signed-in free member is incorrectly shown the "Sign up" link (Casper theme):

Steps to Reproduce

Create new site with Journal theme.
Sign up as free tier member.
Browse to About page, see the Upgrade button.
See the Signup links in the footers and elsewhere.

The bugs can be seen live on my Ghost(Pro) site, https://dogweather.dev.
Ghost Version
Ghost(Pro)
Node.js Version
unknown
How did you install Ghost?
Pro
Database type
Other
Browser & OS version
Safari / current
Relevant log / error output
No response
Code of Conduct

[X] I agree to be friendly and polite to people in this repository

I have moved this issue into the Themes repo for @minimaluminium to take a loo at, as these are not issues with Ghost itself. However, I imagine this theme code pre-dates the new @site.paid_members_enabled flag & this is more "not implemented yet" rather than a bug per
se. Previously, there was no way to tell if payments were enabled on a site, so each theme had payment handling either on or off.

FYI, I've found this workaround for the Dawn theme: hiding "upgrade" elements via JS in the footer injection text field:
<script>
    $('button.members-upgrade').css('display', 'none')
</script>

rather than a bug per se.

There are definitely several problems here. Maybe this should be split out into separate Issues.

One is logic errors in the templates. E.g., above, the signup text is shown regardless if the user is a @member.
Another is incorrect messaging to 'upgrade' when it's not set up in Ghost.
Another is broken dialogs shown to users who click these upgrade buttons.

Each makes the theme unusable in some way.

Hey @dogweather, thanks for the detailed feedbacks here.

the signup text is shown regardless if the user is a @member

The Signup link in the footer is added by the navigation and themes have no control over this. You'd want to replace this with a different link in the navigation settings if you don't want it to appear all the time.

Another is incorrect messaging to 'upgrade' when it's not set up in Ghost

This is now fixed by checking if paid membership is setup with {{#if @setting.paid_members_enabled}}. All you need is now re-installing the theme.

Another is broken dialogs shown to users who click these upgrade buttons

This won't be a problem anymore with the fix above.

Hey @dogweather, thanks for the detailed feedbacks here.

You're welcome, glad I could help. I had these problems while trialing Ghost Pro. I kept my blogs on wordpress.com for now.

Thanks, closing the issue for now. You can re-open it anytime if any of the issues still remains.


Log server version at startup

Fixes #159
Signed-off-by: Andy Goldstein<EMAIL_ADDRESS>

are you intentionally not logging the actual Version?

Not really. But if the version is "master" I'd rather see the git details. And this should work for both tags and branches.

OK.


Deploy the feature server

Configure the Dockerfile of the application in order to expose also a feature server in order to be able to interact with the feature store from another web based service.
@Elkinmt19

Deploy the feature server with an interface that allows to send request from outside the docker network.


Add scroll to top button

The scroll to top button will help the user to get the page top without scrolling upwards.

program name?

KWoC 2023


add release notes for 1.1.1

Signed-off-by: Zhongnan Su<EMAIL_ADDRESS>Description
add release notes for 1.1.1
Issues Resolved
Check List

[ ] New functionality includes testing.

[ ] All tests pass, including unit test, integration test and doctest

[ ] New functionality has been documented.

[ ] New functionality has javadoc added
[ ] New functionality has user manual doc added

[ ] Commits are signed per the DCO using --signoff

By submitting this pull request, I confirm that my contribution is made under the terms of the Apache 2.0 license.
For more information on following Developer Certificate of Origin and signing off your commits, please check here.

Codecov Report

Merging #252 (e7df88d) into 1.1 (d33924f) will decrease coverage by 10.73%.
The diff coverage is n/a.

@@              Coverage Diff              @@
##                1.1     #252       +/-   ##
=============================================
- Coverage     64.15%   53.42%   -10.74%
  Complexity      309      309
=============================================
  Files           102       69       -33
  Lines          4383     2454     -1929
  Branches        658      277      -381
=============================================
- Hits           2812     1311     -1501
+ Misses         1403      978      -425
+ Partials        168      165        -3

Flag
Coverage Δ

dashboards-reports
?

reports-scheduler
53.42% <ø> (ø)

Flags with carried forward coverage won't be shown. Click here to find out more.

Impacted Files
Coverage Δ

...orts/server/routes/utils/converters/backendToUi.ts

...ublic/components/main/report_definitions_table.tsx

...orts/server/routes/utils/converters/uiToBackend.ts

...eports/public/components/utils/settings_service.ts

...report_definitions/delivery/delivery_constants.tsx

...t_definition_details/report_definition_details.tsx

...ions/report_settings/report_settings_constants.tsx

.../report_definitions/report_settings/time_range.tsx

...ashboards-reports/server/utils/validationHelper.ts

...ic/components/main/loading_modal/loading_modal.tsx

... and 23 more

Continue to review full report at Codecov.

Legend - Click here to learn more
Δ = absolute <relative> (impact), ø = not affected, ? = missing data
Powered by Codecov. Last update d33924f...e7df88d. Read the comment docs.


Pdf is not rendering in iframe and throwing error "Invalid or corrupted file"

Attach (recommended) or Link to PDF file here:
Configuration:

Web browser and its version: IE/FF/Chrome
Operating system and its version:windows 2008
PDF.js version:1.9.426
Is a browser extension:no

Steps to reproduce the problem:

added an iframe for viewer.html with a relative url that actually streams the pdf as shown below

2. Instead of rendering pdf its throwing error "Invalid or corrupted file"
What is the expected behavior? (add screenshot)
Instead of rendering pdf its throwing error "Invalid or corrupted file"
What went wrong? (add screenshot)
Does the viewer.html supports a streaming url like shown above??
Link to a viewer (if hosted on a site other than mozilla.github.io/pdf.js or as Firefox/Chrome extension): Apologies that I cannot post the online links as that's not in public facing.

In the issue template it's stated that we cannot help without a running example that shows the issue. We cannot see what ProfileDwnld.asp returns, and it looks like it returns invalid PDF data. You can check if the data returned is in fact a valid PDF file.

Yes what I say is this url is good and its working directly, but its only failing when embed with pdf.js using this ~/web/viewer.html?. So want a reason on why its throwing error when used by pdf.js
Can you please review the code once again as I posted initially and let me know if I need to alter something to make it work.
Note: I know it works fine with iframe but the main reason why I am using pdf.js is to make it consistent accross all the browsers like desktop and mobile as well..
Thanks,

Can I get an update to the question that I posted above??

Without a working example on e.g., JSFiddle it's impossible to tell. I think it's because the file query parameter perhaps expects a direct link to a file, not to a file stream.

Does the viewer.html supports any other query parameter so that it allows me to do what I am trying here?? I always get a url that streams the pdf to the browser and I need to use that url in pdf.js
Please do suggest me if any alternatives can be done to achieve what I am looking for?
Just to re-iterate this is what I am trying but its always throwing error "Invalid pdf structure"

Thanks,

where i can add html file


Get test logs out of image

Mount them in the container during testing.

Also, we should sanitize them!


Trying to load custom font by default

In commit: c71a02530ce951523d794eacb84a209fc4fccda4
This got commited:
io.Fonts->AddFontFromFileTTF("resources/fa-solid-900.ttf", FONT_AWESOME_ICON_SIZE, &icons_config, nullptr);
//io.Fonts->AddFontFromMemoryCompressedTTF((void*)fa_solid_900_compressed_data, fa_solid_900_compressed_size, FONT_AWESOME_ICON_SIZE, &icons_config, icons_ranges);
it should probably be just the commented row and delete the other one:
io.Fonts->AddFontFromMemoryCompressedTTF((void*)fa_solid_900_compressed_data, fa_solid_900_compressed_size, FONT_AWESOME_ICON_SIZE, &icons_config, icons_ranges);

This has been fixed. Thanks for reporting it.


Error stopping or starting containers

Description
In Chrome (59) when stopping/starting a container (e.g. wordpress) I get an error "Failure to retrieve containers"

Steps to reproduce the issue:

Start nginx + letencrypt helper
Start portainer
start database + phpmydmin
Start website 1
Start website 2
6 Stop / Start website 1 or 2

Technical details:

Portainer version: 1.13.2
Target Docker version (the host/cluster you manage): 17.05 ce
Platform (windows/linux): ubuntu 17.04
Command used to start Portainer (docker run -p 9000:9000 portainer/portainer): docker-compose up -d
Target Swarm version (if applicable):
Browser: chrome, firefox

Investigation so far:

Issue is only occuring on Chrome 59
Dev tools show a failing HTTP request (https://<domain>/api/docker/1/containers/json?all=1) with the following status: no status = (canceled)
Tested behind a Nginx reverse-proxy
Cannot reproduce on Chrome 53

Following our discussion on Slack, please retry by starting a Portainer container without using a reverse proxy (docker run -d -p 9000:9000 -v /var/run/docker.sock:/var/run/docker.sock portainer/portainer) to see if it's related to your Nginx configuration.

I have tested Chrome 53 and had same error
I have not got to testing portainer without reverse proxy but i did the following:

created a generic wordpress container
Test under chrome 59,  i can stop and start ok

it looks like the custom wordpress containers are causing the issue

update:
I have now tested portainer without nginx proxy and its working. It points to my config for nginx so will review.


Fence error on AMD IGPU

Template
If you dont understand something just leave it.
If you can provide more detailed information than the template allows for, please ignore the template and present all of your findings.

Version of vulkano: probably 0.34.0, I pulled it from github repo instead of crate.io
OS: KDE Neon 5.27
GPU (the selected PhysicalDevice): Ryzen 4500U. It's IGPU
GPU Driver: TODO
Upload of a reasonably minimal complete main.rs file that demonstrates the issue: TODO

Issue
I'm unable to present swapchain with "then_swapchain_present" because it says fence is already in use.

 Error Log
VUID-vkQueueSubmit-fence-00064(ERROR / SPEC): msgNum: -1082734195 - Validation Error: [ VUID-vkQueueSubmit-fence-00064 ] Object 0: handle = 0x55fb7d466d50, type = VK_OBJECT_TYPE_QUEUE; Object 1: handle = 0x9fde6b0000000014, type = VK_OBJECT_TYPE_FENCE; | MessageID = 0xbf76c98d | vkQueueSubmit():  (VkFence 0x9fde6b0000000014[]) is already in use by another submission. The Vulkan spec states: If fence is not VK_NULL_HANDLE, fence must not be associated with any other queue command that has not yet completed execution on that queue (https://vulkan.lunarg.com/doc/view/1.3.275.0/linux/1.3-extensions/vkspec.html#VUID-vkQueueSubmit-fence-00064)
    Objects: 2
        [0] 0x55fb7d466d50, type: 4, name: NULL
        [1] 0x9fde6b0000000014, type: 7, name: NULL
VUID-VkPresentInfoKHR-pImageIndices-01430(ERROR / SPEC): msgNum:<PHONE_NUMBER> - Validation Error: [ VUID-VkPresentInfoKHR-pImageIndices-01430 ] Object 0: handle = 0xfab64d0000000002, type = VK_OBJECT_TYPE_SWAPCHAIN_KHR; | MessageID = 0x48ad24c6 | vkQueuePresentKHR(): pPresentInfo->pSwapchains[0] image at index 0 was not acquired from the swapchain. The Vulkan spec states: Each element of pImageIndices must be the index of a presentable image acquired from the swapchain specified by the corresponding element of the pSwapchains array, and the presented image subresource must be in the VK_IMAGE_LAYOUT_PRESENT_SRC_KHR or VK_IMAGE_LAYOUT_SHARED_PRESENT_KHR layout at the time the operation is executed on a VkDevice (https://vulkan.lunarg.com/doc/view/1.3.275.0/linux/1.3-extensions/vkspec.html#VUID-VkPresentInfoKHR-pImageIndices-01430)
    Objects: 1
        [0] 0xfab64d0000000002, type:<PHONE_NUMBER>, name: NULL
thread 'main' panicked at game/src/main.rs:698:25:

What bugs me is that this happens on the first frame. As a test I tried triangle example updated to newer version of both winit and vulkan but the issue is exactly the same: https://github.com/vulkano-rs/vulkano/blob/v0.34.0/examples/src/bin/triangle.rs

 Updated version
// Copyright (c) 2016 The vulkano developers
// Licensed under the Apache License, Version 2.0
// <LICENSE-APACHE or
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT
// license <LICENSE-MIT or https://opensource.org/licenses/MIT>,
// at your option. All files in the project carrying such
// notice may not be copied, modified, or distributed except
// according to those terms.

// Welcome to the triangle example!
//
// This is the only example that is entirely detailed. All the other examples avoid code
// duplication by using helper functions.
//
// This example assumes that you are already more or less familiar with graphics programming and
// that you want to learn Vulkan. This means that for example it won't go into details about what a
// vertex or a shader is.

use std::sync::Arc;
use vulkano::{
    buffer::{Buffer, BufferContents, BufferCreateInfo, BufferUsage},
    command_buffer::{
        allocator::StandardCommandBufferAllocator, RecordingCommandBuffer, CommandBufferUsage,
        RenderPassBeginInfo, SubpassBeginInfo, SubpassContents,
    },
    device::{
        physical::PhysicalDeviceType, Device, DeviceCreateInfo, DeviceExtensions, QueueCreateInfo,
        QueueFlags,
    },
    image::{view::ImageView, Image, ImageUsage},
    instance::{Instance, InstanceCreateFlags, InstanceCreateInfo},
    memory::allocator::{AllocationCreateInfo, MemoryTypeFilter, StandardMemoryAllocator},
    pipeline::{
        graphics::{
            color_blend::{ColorBlendAttachmentState, ColorBlendState},
            input_assembly::InputAssemblyState,
            multisample::MultisampleState,
            rasterization::RasterizationState,
            vertex_input::VertexDefinition,
            viewport::{Viewport, ViewportState},
            GraphicsPipelineCreateInfo,
        },
        layout::PipelineDescriptorSetLayoutCreateInfo,
        DynamicState, GraphicsPipeline, PipelineLayout, PipelineShaderStageCreateInfo,
    },
    render_pass::{Framebuffer, FramebufferCreateInfo, RenderPass, Subpass},
    swapchain::{
        acquire_next_image, Surface, Swapchain, SwapchainCreateInfo, SwapchainPresentInfo,
    },
    sync::{self, GpuFuture},
    Validated, VulkanError, VulkanLibrary,
};
use vulkano::command_buffer::{CommandBufferBeginInfo, CommandBufferLevel};
use vulkano::pipeline::graphics::vertex_input;
use vulkano::pipeline::graphics::vertex_input::Vertex;
use winit::{
    event::{Event, WindowEvent},
    event_loop::{ControlFlow, EventLoop},
    window::WindowBuilder,
};

fn main() {
    let event_loop = EventLoop::new().unwrap();

    let library = VulkanLibrary::new().unwrap();

    // The first step of any Vulkan program is to create an instance.
    //
    // When we create an instance, we have to pass a list of extensions that we want to enable.
    //
    // All the window-drawing functionalities are part of non-core extensions that we need to
    // enable manually. To do so, we ask `Surface` for the list of extensions required to draw to
    // a window.
    let required_extensions = Surface::required_extensions(&event_loop).unwrap();

    // Now creating the instance.
    let instance = Instance::new(
        library,
        InstanceCreateInfo {
            // Enable enumerating devices that use non-conformant Vulkan implementations.
            // (e.g. MoltenVK)
            flags: InstanceCreateFlags::ENUMERATE_PORTABILITY,
            enabled_extensions: required_extensions,
            enabled_layers: vec!["VK_LAYER_KHRONOS_validation".to_string()],
            ..Default::default()
        },
    )
        .unwrap();

    // The objective of this example is to draw a triangle on a window. To do so, we first need to
    // create the window. We use the `WindowBuilder` from the `winit` crate to do that here.
    //
    // Before we can render to a window, we must first create a `vulkano::swapchain::Surface`
    // object from it, which represents the drawable surface of a window. For that we must wrap the
    // `winit::window::Window` in an `Arc`.
    let window = Arc::new(WindowBuilder::new().build(&event_loop).unwrap());
    let surface = Surface::from_window(instance.clone(), window.clone()).unwrap();

    // Choose device extensions that we're going to use. In order to present images to a surface,
    // we need a `Swapchain`, which is provided by the `khr_swapchain` extension.
    let device_extensions = DeviceExtensions {
        khr_swapchain: true,
        ..DeviceExtensions::empty()
    };

    // We then choose which physical device to use. First, we enumerate all the available physical
    // devices, then apply filters to narrow them down to those that can support our needs.
    let (physical_device, queue_family_index) = instance
        .enumerate_physical_devices()
        .unwrap()
        .filter(|p| {
            // Some devices may not support the extensions or features that your application, or
            // report properties and limits that are not sufficient for your application. These
            // should be filtered out here.
            p.supported_extensions().contains(&device_extensions)
        })
        .filter_map(|p| {
            // For each physical device, we try to find a suitable queue family that will execute
            // our draw commands.
            //
            // Devices can provide multiple queues to run commands in parallel (for example a draw
            // queue and a compute queue), similar to CPU threads. This is something you have to
            // have to manage manually in Vulkan. Queues of the same type belong to the same queue
            // family.
            //
            // Here, we look for a single queue family that is suitable for our purposes. In a
            // real-world application, you may want to use a separate dedicated transfer queue to
            // handle data transfers in parallel with graphics operations. You may also need a
            // separate queue for compute operations, if your application uses those.
            p.queue_family_properties()
                .iter()
                .enumerate()
                .position(|(i, q)| {
                    // We select a queue family that supports graphics operations. When drawing to
                    // a window surface, as we do in this example, we also need to check that
                    // queues in this queue family are capable of presenting images to the surface.
                    q.queue_flags.intersects(QueueFlags::GRAPHICS)
                        && p.surface_support(i as u32, &surface).unwrap_or(false)
                })
                // The code here searches for the first queue family that is suitable. If none is
                // found, `None` is returned to `filter_map`, which disqualifies this physical
                // device.
                .map(|i| (p, i as u32))
        })
        // All the physical devices that pass the filters above are suitable for the application.
        // However, not every device is equal, some are preferred over others. Now, we assign each
        // physical device a score, and pick the device with the lowest ("best") score.
        //
        // In this example, we simply select the best-scoring device to use in the application.
        // In a real-world setting, you may want to use the best-scoring device only as a "default"
        // or "recommended" device, and let the user choose the device themself.
        .min_by_key(|(p, _)| {
            // We assign a lower score to device types that are likely to be faster/better.
            match p.properties().device_type {
                PhysicalDeviceType::DiscreteGpu => 0,
                PhysicalDeviceType::IntegratedGpu => 1,
                PhysicalDeviceType::VirtualGpu => 2,
                PhysicalDeviceType::Cpu => 3,
                PhysicalDeviceType::Other => 4,
                _ => 5,
            }
        })
        .expect("no suitable physical device found");

    // Some little debug infos.
    println!(
        "Using device: {} (type: {:?})",
        physical_device.properties().device_name,
        physical_device.properties().device_type,
    );

    // Now initializing the device. This is probably the most important object of Vulkan.
    //
    // An iterator of created queues is returned by the function alongside the device.
    let (device, mut queues) = Device::new(
        // Which physical device to connect to.
        physical_device,
        DeviceCreateInfo {
            // A list of optional features and extensions that our program needs to work correctly.
            // Some parts of the Vulkan specs are optional and must be enabled manually at device
            // creation. In this example the only thing we are going to need is the `khr_swapchain`
            // extension that allows us to draw to a window.
            enabled_extensions: device_extensions,

            // The list of queues that we are going to use. Here we only use one queue, from the
            // previously chosen queue family.
            queue_create_infos: vec![QueueCreateInfo {
                queue_family_index,
                ..Default::default()
            }],

            ..Default::default()
        },
    )
        .unwrap();

    // Since we can request multiple queues, the `queues` variable is in fact an iterator. We only
    // use one queue in this example, so we just retrieve the first and only element of the
    // iterator.
    let queue = queues.next().unwrap();

    // Before we can draw on the surface, we have to create what is called a swapchain. Creating a
    // swapchain allocates the color buffers that will contain the image that will ultimately be
    // visible on the screen. These images are returned alongside the swapchain.
    let (mut swapchain, images) = {
        // Querying the capabilities of the surface. When we create the swapchain we can only pass
        // values that are allowed by the capabilities.
        let surface_capabilities = device
            .physical_device()
            .surface_capabilities(&surface, Default::default())
            .unwrap();

        // Choosing the internal format that the images will have.
        let image_format = device
            .physical_device()
            .surface_formats(&surface, Default::default())
            .unwrap()[0]
            .0;

        // Please take a look at the docs for the meaning of the parameters we didn't mention.
        Swapchain::new(
            device.clone(),
            surface,
            SwapchainCreateInfo {
                // Some drivers report an `min_image_count` of 1, but fullscreen mode requires at
                // least 2. Therefore we must ensure the count is at least 2, otherwise the program
                // would crash when entering fullscreen mode on those drivers.
                min_image_count: surface_capabilities.min_image_count.max(2),

                image_format,

                // The size of the window, only used to initially setup the swapchain.
                //
                // NOTE:
                // On some drivers the swapchain extent is specified by
                // `surface_capabilities.current_extent` and the swapchain size must use this
                // extent. This extent is always the same as the window size.
                //
                // However, other drivers don't specify a value, i.e.
                // `surface_capabilities.current_extent` is `None`. These drivers will allow
                // anything, but the only sensible value is the window size.
                //
                // Both of these cases need the swapchain to use the window size, so we just
                // use that.
                image_extent: window.inner_size().into(),

                image_usage: ImageUsage::COLOR_ATTACHMENT,

                // The alpha mode indicates how the alpha value of the final image will behave. For
                // example, you can choose whether the window will be opaque or transparent.
                composite_alpha: surface_capabilities
                    .supported_composite_alpha
                    .into_iter()
                    .next()
                    .unwrap(),

                ..Default::default()
            },
        )
            .unwrap()
    };

    let memory_allocator = Arc::new(StandardMemoryAllocator::new_default(device.clone()));

    // We now create a buffer that will store the shape of our triangle. We use `#[repr(C)]` here
    // to force rustc to use a defined layout for our data, as the default representation has *no
    // guarantees*.
    #[derive(BufferContents, Vertex)]
    #[repr(C)]
    struct Vertex {
        #[format(R32G32_SFLOAT)]
        position: [f32; 2],
    }

    let vertices = [
        Vertex {
            position: [-0.5, -0.25],
        },
        Vertex {
            position: [0.0, 0.5],
        },
        Vertex {
            position: [0.25, -0.1],
        },
    ];
    let vertex_buffer = Buffer::from_iter(
        memory_allocator,
        BufferCreateInfo {
            usage: BufferUsage::VERTEX_BUFFER,
            ..Default::default()
        },
        AllocationCreateInfo {
            memory_type_filter: MemoryTypeFilter::PREFER_DEVICE
                | MemoryTypeFilter::HOST_SEQUENTIAL_WRITE,
            ..Default::default()
        },
        vertices,
    )
        .unwrap();

    // The next step is to create the shaders.
    //
    // The raw shader creation API provided by the vulkano library is unsafe for various reasons,
    // so The `shader!` macro provides a way to generate a Rust module from GLSL source - in the
    // example below, the source is provided as a string input directly to the shader, but a path
    // to a source file can be provided as well. Note that the user must specify the type of shader
    // (e.g. "vertex", "fragment", etc.) using the `ty` option of the macro.
    //
    // The items generated by the `shader!` macro include a `load` function which loads the shader
    // using an input logical device. The module also includes type definitions for layout
    // structures defined in the shader source, for example uniforms and push constants.
    //
    // A more detailed overview of what the `shader!` macro generates can be found in the
    // vulkano-shaders crate docs. You can view them at https://docs.rs/vulkano-shaders/
    mod vs {
        vulkano_shaders::shader! {
            ty: "vertex",
            src: r"
                #version 450

                layout(location = 0) in vec2 position;

                void main() {
                    gl_Position = vec4(position, 0.0, 1.0);
                }
            ",
        }
    }

    mod fs {
        vulkano_shaders::shader! {
            ty: "fragment",
            src: r"
                #version 450

                layout(location = 0) out vec4 f_color;

                void main() {
                    f_color = vec4(1.0, 0.0, 0.0, 1.0);
                }
            ",
        }
    }

    // At this point, OpenGL initialization would be finished. However in Vulkan it is not. OpenGL
    // implicitly does a lot of computation whenever you draw. In Vulkan, you have to do all this
    // manually.

    // The next step is to create a *render pass*, which is an object that describes where the
    // output of the graphics pipeline will go. It describes the layout of the images where the
    // colors, depth and/or stencil information will be written.
    let render_pass = vulkano::single_pass_renderpass!(
        device.clone(),
        attachments: {
            // `color` is a custom name we give to the first and only attachment.
            color: {
                // `format: <ty>` indicates the type of the format of the image. This has to be one
                // of the types of the `vulkano::format` module (or alternatively one of your
                // structs that implements the `FormatDesc` trait). Here we use the same format as
                // the swapchain.
                format: swapchain.image_format(),
                // `samples: 1` means that we ask the GPU to use one sample to determine the value
                // of each pixel in the color attachment. We could use a larger value
                // (multisampling) for antialiasing. An example of this can be found in
                // msaa-renderpass.rs.
                samples: 1,
                // `load_op: Clear` means that we ask the GPU to clear the content of this
                // attachment at the start of the drawing.
                load_op: Clear,
                // `store_op: Store` means that we ask the GPU to store the output of the draw in
                // the actual image. We could also ask it to discard the result.
                store_op: Store,
            },
        },
        pass: {
            // We use the attachment named `color` as the one and only color attachment.
            color: [color],
            // No depth-stencil attachment is indicated with empty brackets.
            depth_stencil: {},
        },
    )
        .unwrap();

    // Before we draw, we have to create what is called a **pipeline**. A pipeline describes how
    // a GPU operation is to be performed. It is similar to an OpenGL program, but it also contains
    // many settings for customization, all baked into a single object. For drawing, we create
    // a **graphics** pipeline, but there are also other types of pipeline.
    let pipeline = {
        // First, we load the shaders that the pipeline will use:
        // the vertex shader and the fragment shader.
        //
        // A Vulkan shader can in theory contain multiple entry points, so we have to specify which
        // one.
        let vs = vs::load(device.clone())
            .unwrap()
            .entry_point("main")
            .unwrap();
        let fs = fs::load(device.clone())
            .unwrap()
            .entry_point("main")
            .unwrap();

        // Automatically generate a vertex input state from the vertex shader's input interface,
        // that takes a single vertex buffer containing `Vertex` structs.
        let vertex_input_state = Vertex::per_vertex()
            .definition(&vs.info().input_interface)
            .unwrap();

        // Make a list of the shader stages that the pipeline will have.
        let stages = [
            PipelineShaderStageCreateInfo::new(vs),
            PipelineShaderStageCreateInfo::new(fs),
        ];

        // We must now create a **pipeline layout** object, which describes the locations and types of
        // descriptor sets and push constants used by the shaders in the pipeline.
        //
        // Multiple pipelines can share a common layout object, which is more efficient.
        // The shaders in a pipeline must use a subset of the resources described in its pipeline
        // layout, but the pipeline layout is allowed to contain resources that are not present in the
        // shaders; they can be used by shaders in other pipelines that share the same layout.
        // Thus, it is a good idea to design shaders so that many pipelines have common resource
        // locations, which allows them to share pipeline layouts.
        let layout = PipelineLayout::new(
            device.clone(),
            // Since we only have one pipeline in this example, and thus one pipeline layout,
            // we automatically generate the creation info for it from the resources used in the
            // shaders. In a real application, you would specify this information manually so that you
            // can re-use one layout in multiple pipelines.
            PipelineDescriptorSetLayoutCreateInfo::from_stages(&stages)
                .into_pipeline_layout_create_info(device.clone())
                .unwrap(),
        )
            .unwrap();

        // We have to indicate which subpass of which render pass this pipeline is going to be used
        // in. The pipeline will only be usable from this particular subpass.
        let subpass = Subpass::from(render_pass.clone(), 0).unwrap();

        // Finally, create the pipeline.
        GraphicsPipeline::new(
            device.clone(),
            None,
            GraphicsPipelineCreateInfo {
                stages: stages.into_iter().collect(),
                // How vertex data is read from the vertex buffers into the vertex shader.
                vertex_input_state: Some(vertex_input_state),
                // How vertices are arranged into primitive shapes.
                // The default primitive shape is a triangle.
                input_assembly_state: Some(InputAssemblyState::default()),
                // How primitives are transformed and clipped to fit the framebuffer.
                // We use a resizable viewport, set to draw over the entire window.
                viewport_state: Some(ViewportState::default()),
                // How polygons are culled and converted into a raster of pixels.
                // The default value does not perform any culling.
                rasterization_state: Some(RasterizationState::default()),
                // How multiple fragment shader samples are converted to a single pixel value.
                // The default value does not perform any multisampling.
                multisample_state: Some(MultisampleState::default()),
                // How pixel values are combined with the values already present in the framebuffer.
                // The default value overwrites the old value with the new one, without any blending.
                color_blend_state: Some(ColorBlendState::with_attachment_states(
                    subpass.num_color_attachments(),
                    ColorBlendAttachmentState::default(),
                )),
                // Dynamic states allows us to specify parts of the pipeline settings when
                // recording the command buffer, before we perform drawing.
                // Here, we specify that the viewport should be dynamic.
                dynamic_state: [DynamicState::Viewport].into_iter().collect(),
                subpass: Some(subpass.into()),
                ..GraphicsPipelineCreateInfo::layout(layout)
            },
        )
            .unwrap()
    };

    // Dynamic viewports allow us to recreate just the viewport when the window is resized.
    // Otherwise we would have to recreate the whole pipeline.
    let mut viewport = Viewport {
        offset: [0.0, 0.0],
        extent: [0.0, 0.0],
        depth_range: 0.0..=1.0,
    };

    // The render pass we created above only describes the layout of our framebuffers. Before we
    // can draw we also need to create the actual framebuffers.
    //
    // Since we need to draw to multiple images, we are going to create a different framebuffer for
    // each image.
    let mut framebuffers = window_size_dependent_setup(&images, render_pass.clone(), &mut viewport);

    // Before we can start creating and recording command buffers, we need a way of allocating
    // them. Vulkano provides a command buffer allocator, which manages raw Vulkan command pools
    // underneath and provides a safe interface for them.
    let command_buffer_allocator: Arc<_> =
        StandardCommandBufferAllocator::new(device.clone(), Default::default()).into();

    // Initialization is finally finished!

    // In some situations, the swapchain will become invalid by itself. This includes for example
    // when the window is resized (as the images of the swapchain will no longer match the
    // window's) or, on Android, when the application went to the background and goes back to the
    // foreground.
    //
    // In this situation, acquiring a swapchain image or presenting it will return an error.
    // Rendering to an image of that swapchain will not produce any error, but may or may not work.
    // To continue rendering, we need to recreate the swapchain by creating a new swapchain. Here,
    // we remember that we need to do this for the next loop iteration.
    let mut recreate_swapchain = false;

    // In the loop below we are going to submit commands to the GPU. Submitting a command produces
    // an object that implements the `GpuFuture` trait, which holds the resources for as long as
    // they are in use by the GPU.
    //
    // Destroying the `GpuFuture` blocks until the GPU is finished executing it. In order to avoid
    // that, we store the submission of the previous frame here.
    let mut previous_frame_end = Some(sync::now(device.clone()).boxed());

    event_loop.run(move |event, target| {
        match event {
            Event::WindowEvent {
                event: WindowEvent::CloseRequested,
                ..
            } => {
                target.exit();
            }
            Event::WindowEvent {
                event: WindowEvent::Resized(_),
                ..
            } => {
                recreate_swapchain = true;
            }
            Event::AboutToWait => {
                window.request_redraw();
            }
            Event::WindowEvent { event: WindowEvent::RedrawRequested, .. } => {
                dbg!("drawing");
                // Do not draw the frame when the screen size is zero. On Windows, this can
                // occur when minimizing the application.
                let image_extent: [u32; 2] = window.inner_size().into();

                if image_extent.contains(&0) {
                    return;
                }

                // It is important to call this function from time to time, otherwise resources
                // will keep accumulating and you will eventually reach an out of memory error.
                // Calling this function polls various fences in order to determine what the GPU
                // has already processed, and frees the resources that are no longer needed.
                previous_frame_end.as_mut().unwrap().cleanup_finished();

                // Whenever the window resizes we need to recreate everything dependent on the
                // window size. In this example that includes the swapchain, the framebuffers and
                // the dynamic state viewport.
                if recreate_swapchain {
                    // Use the new dimensions of the window.

                    let (new_swapchain, new_images) = swapchain
                        .recreate(SwapchainCreateInfo {
                            image_extent,
                            ..swapchain.create_info()
                        })
                        .expect("failed to recreate swapchain");

                    swapchain = new_swapchain;

                    // Because framebuffers contains a reference to the old swapchain, we need to
                    // recreate framebuffers as well.
                    framebuffers = window_size_dependent_setup(
                        &new_images,
                        render_pass.clone(),
                        &mut viewport,
                    );

                    recreate_swapchain = false;
                }

                // Before we can draw on the output, we have to *acquire* an image from the
                // swapchain. If no image is available (which happens if you submit draw commands
                // too quickly), then the function will block. This operation returns the index of
                // the image that we are allowed to draw upon.
                //
                // This function can block if no image is available. The parameter is an optional
                // timeout after which the function call will return an error.
                let (image_index, suboptimal, acquire_future) =
                    match acquire_next_image(swapchain.clone(), None).map_err(Validated::unwrap) {
                        Ok(r) => r,
                        Err(VulkanError::OutOfDate) => {
                            recreate_swapchain = true;
                            return;
                        }
                        Err(e) => panic!("failed to acquire next image: {e}"),
                    };

                // `acquire_next_image` can be successful, but suboptimal. This means that the
                // swapchain image will still work, but it may not display correctly. With some
                // drivers this can be when the window resizes, but it may not cause the swapchain
                // to become out of date.
                if suboptimal {
                    recreate_swapchain = true;
                }

                // In order to draw, we have to build a *command buffer*. The command buffer object
                // holds the list of commands that are going to be executed.
                //
                // Building a command buffer is an expensive operation (usually a few hundred
                // microseconds), but it is known to be a hot path in the driver and is expected to
                // be optimized.
                //
                // Note that we have to pass a queue family when we create the command buffer. The
                // command buffer will only be executable on that given queue family.
                let mut builder = RecordingCommandBuffer::new(
                    command_buffer_allocator.clone(),
                    queue.queue_family_index(),
                    CommandBufferLevel::Primary,
                    CommandBufferBeginInfo {
                        usage: CommandBufferUsage::OneTimeSubmit,
                        ..Default::default()
                    },
                ).unwrap();

                unsafe {
                    builder
                        // Before we can draw, we have to *enter a render pass*.
                        .begin_render_pass(
                            RenderPassBeginInfo {
                                // A list of values to clear the attachments with. This list contains
                                // one item for each attachment in the render pass. In this case, there
                                // is only one attachment, and we clear it with a blue color.
                                //
                                // Only attachments that have `AttachmentLoadOp::Clear` are provided
                                // with clear values, any others should use `None` as the clear value.
                                clear_values: vec![Some([0.0, 0.0, 1.0, 1.0].into())],

                                ..RenderPassBeginInfo::framebuffer(
                                    framebuffers[image_index as usize].clone(),
                                )
                            },
                            SubpassBeginInfo {
                                // The contents of the first (and only) subpass.
                                // This can be either `Inline` or `SecondaryCommandBuffers`.
                                // The latter is a bit more advanced and is not covered here.
                                contents: SubpassContents::Inline,
                                ..Default::default()
                            },
                        )
                        .unwrap()
                        // We are now inside the first subpass of the render pass.
                        //
                        // TODO: Document state setting and how it affects subsequent draw commands.
                        .set_viewport(0, [viewport.clone()].into_iter().collect())
                        .unwrap()
                        .bind_pipeline_graphics(pipeline.clone())
                        .unwrap()
                        .bind_vertex_buffers(0, vertex_buffer.clone())
                        .unwrap()
                        // We add a draw command.
                        .draw(vertex_buffer.len() as u32, 1, 0, 0)
                        .unwrap()
                        // We leave the render pass. Note that if we had multiple subpasses we could
                        // have called `next_subpass` to jump to the next subpass.
                        .end_render_pass(Default::default())
                        .unwrap();
                }

                // Finish building the command buffer by calling `build`.
                let command_buffer = builder.end().unwrap();

                let future = previous_frame_end
                    .take()
                    .unwrap()
                    .join(acquire_future)
                    .then_execute(queue.clone(), command_buffer)
                    .unwrap()
                    // The color output is now expected to contain our triangle. But in order to
                    // show it on the screen, we have to *present* the image by calling
                    // `then_swapchain_present`.
                    //
                    // This function does not actually present the image immediately. Instead it
                    // submits a present command at the end of the queue. This means that it will
                    // only be presented once the GPU has finished executing the command buffer
                    // that draws the triangle.
                    .then_swapchain_present(
                        queue.clone(),
                        SwapchainPresentInfo::swapchain_image_index(swapchain.clone(), image_index),
                    )
                    .then_signal_fence_and_flush();

                match future.map_err(Validated::unwrap) {
                    Ok(future) => {
                        previous_frame_end = Some(future.boxed());
                    }
                    Err(VulkanError::OutOfDate) => {
                        recreate_swapchain = true;
                        previous_frame_end = Some(sync::now(device.clone()).boxed());
                    }
                    Err(e) => {
                        panic!("failed to flush future: {e}");
                        // previous_frame_end = Some(sync::now(device.clone()).boxed());
                    }
                }
            }
            _ => (),
        }
    }).unwrap();
}

/// This function is called once during initialization, then again whenever the window is resized.
fn window_size_dependent_setup(
    images: &[Arc<Image>],
    render_pass: Arc<RenderPass>,
    viewport: &mut Viewport,
) -> Vec<Arc<Framebuffer>> {
    let extent = images[0].extent();
    viewport.extent = [extent[0] as f32, extent[1] as f32];

    images
        .iter()
        .map(|image| {
            let view = ImageView::new_default(image.clone()).unwrap();
            Framebuffer::new(
                render_pass.clone(),
                FramebufferCreateInfo {
                    attachments: vec![view],
                    ..Default::default()
                },
            )
                .unwrap()
        })
        .collect::<Vec<_>>()
}

Output of glxinfo if this helps:
$ glxinfo | grep -iE 'vendor:|device:|version:'
GLX version: 1.4
    Vendor: AMD (0x1002)
    Device: AMD Radeon Graphics (renoir, LLVM 16.0.6, DRM 3.54, 6.6.0-rc4-kindergarten+) (0x1636)
    Version: 23.2.0
    Max core profile version: 4.6
    Max compat profile version: 4.6
    Max GLES1 profile version: 1.1
    Max GLES[23] profile version: 3.2

I recently had other validation error so installed LunarG SDK. So I think It's latest?

Yeah changing the kernel version worked.


How to combine Nginx trace spans with backend service call trace spans into a single trace.

Describe the bug
I am trying to make a call to user service from Nginx -> UserService -> Calculator service to perform an addition operation. I am using the docker image: nginx:otel
There are two separate traces coming one for unknown_service:nginx:  and  another UserRequestService: HTTP GET
unknown_service:nginx: screenshot as below

UserRequestService  screenshot as below

A clear and concise description of what the bug is.
nginx and user service trace span are coming separately, they should comes together.
To reproduce
Steps to reproduce the behavior:

Run below docker-compose
Docker compose file
otel-config.yaml file
nginx.conf file

docker-compose up

call URL from browser "http://localhost:8082/api/UserRequest/add?num1=5&num2=24"

Expected behavior
Nginx trace span should come with User Service span.
E.g.
nginx ->  proxy to the backend (User Service)  -> Calculator Service
Your environment

Version/release of this project or specific commit

Target deployment platform

Additional context
Add any other context about the problem here.
I have tried Parent-based Tracing, but it give only User Service -> Calculator Service trace

It's not clear what is here to fix in Nginx OTel module. Can you restate the problem in terms of Nginx generated trace attributes/headers, i.e. do we need to add/change something?
I'd guess, that your "UserService" just ignores Nginx generated "traceparent" header.

Thanks for the pointer, I have added the below the code for propagation
services.AddOpenTelemetryTracing(   (builder) => builder       .AddAspNetCoreInstrumentation()       .AddHttpClientInstrumentation()       .AddJaegerExporter(j => { j.AgentHost = serviceName; j.AgentPort = 6831; })       .SetResourceBuilder(ResourceBuilder.CreateDefault().AddService("UserRequest")) );
		<!--Open Telemetry--> 		<PackageReference Include="OpenTelemetry.Exporter.Jaeger" Version="1.0.0-rc1.1" /> 		<PackageReference Include="OpenTelemetry.Extensions.Hosting" Version="1.0.0-rc1.1" /> 		<PackageReference Include="OpenTelemetry.Instrumentation.AspNetCore" Version="1.0.0-rc1.1" /> 		<PackageReference Include="OpenTelemetry.Instrumentation.Http" Version="1.0.0-rc1.1" />


Identify and configure all BPNs within catena-x to allow them accessing trace-x registry

As ... ,
I want ... ,
so that ... .
Hints / Details

Currently only allowed bpns can access trace-x registry. For successful e2e tests we need to configure relevant bpns. As this is currently unknown we could add all existing bpns to the allowed ones.
https://github.com/eclipse-tractusx/bpdm/tree/main/docs/postman get all available BPNL and add this to list

Acceptance Criteria

[ ] BPN List has been queried (BPN Service) or BPNs have been provided by the product owner.
[ ] BPN List has been added to the allowed bpn for local data provisioning as well as testdata used by python upload script

Out of Scope

...

Closing as not planned since it is a duplication to: https://github.com/eclipse-tractusx/traceability-foss/issues/740


Use Terraform to enable GCP APIs

This PR moves GCP API enablement from the gcp_setup.sh script into Terraform. It also tees up some requirements for a subsequent PR to create and manage the required GCP service accounts, without needing to download long-lived service account keys. Note that this makes gcp_project_id a required input variable.

Added the changes to .gitignore and the initial commit of the lockfile with all currently used providers (including Google).

Added the changes to .gitignore and the initial commit of the lockfile with all currently used providers (including Google).


python3.pkgs.flufl_lock: 5.0.5 -> 5.1

Motivation for this change
Things done

[x] Tested using sandboxing (nix.useSandbox on NixOS, or option sandbox in nix.conf on non-NixOS linux)
Built on platform(s)

[x] NixOS
[ ] macOS
[ ] other Linux distributions

[ ] Tested via one or more NixOS test(s) if existing and applicable for the change (look inside nixos/tests)
[ ] Tested compilation of all packages that depend on this change using nix-shell -p nixpkgs-review --run "nixpkgs-review wip"
[ ] Tested execution of all binary files (usually in ./result/bin/)
21.11 Release Notes (or backporting 21.05 Release notes)

[ ] (Package updates) Added a release notes entry if the change is major or breaking
[ ] (Module updates) Added a release notes entry if the change is significant
[ ] (Module addition) Added a release notes entry if adding a new NixOS module

[x] Fits CONTRIBUTING.md.

Result of nixpkgs-review pr 133162 at 792abce1 run on x86_64-linux 1

5 packages failed to build:

mailman
python38Packages.mailman
python38Packages.mailman-hyperkitty
python39Packages.mailman
python39Packages.mailman-hyperkitty

8 packages built successfully:

mailman-web (python39Packages.mailman-web)
python38Packages.cartopy
python38Packages.flufl_lock
python38Packages.hyperkitty
python38Packages.mailman-web
python39Packages.cartopy
python39Packages.flufl_lock
python39Packages.hyperkitty

Note that build failures may predate this PR, and could be nondeterministic or hardware dependent.
Please exercise your independent judgement. Does something look off? Please file an issue or reach out on IRC.

This is a semi-automatic executed nixpkgs-review with nixpkgs-review-checks extension. It is checked by a human on a best effort basis and does not build all packages (e.g. lumo, tensorflow or pytorch).
Result of nixpkgs-review pr 133162 run on x86_64-linux 1

5 packages failed to build and already failed to build on hydra master:

mailman: log was empty
python38Packages.mailman: log was empty
python38Packages.mailman-hyperkitty: log was empty
python39Packages.mailman: log was empty
python39Packages.mailman-hyperkitty: log was empty

8 packages built:

mailman-web (python39Packages.mailman-web)
python38Packages.cartopy
python38Packages.flufl_lock
python38Packages.hyperkitty
python38Packages.mailman-web
python39Packages.cartopy
python39Packages.flufl_lock
python39Packages.hyperkitty


Errors from entire project not just opened buffers

Hi i really like this plugin.
I have a typescript project and i want to be able to see the errors that occur in all of the files in my project not just the buffers that i have open. Is this possible?
For example if i rename a function, trouble will show me error for the buffer that i have open which contains the old fnction name, but for the files that i dont have open that also contain the old function name, it does not show me an error.

That's a limitation of the typescript lsp server. We can only show what we get from LSP. Nothing more

is there a way to make the lsp scan all files in the src folder though?


distinguish core-members

isCoreMember: true could using doors unlimited or with different, lower rate?

With camera it can be unlimited.


12/6/2022 PM Publish

PR Summary

PR Checklist

[ ] Descriptive Title: This PR's title is a synopsis of the changes it proposes.
[ ] Summary: This PR's summary describes the scope and intent of the change.
[ ] Contributor's Guide: I have read the contributors guide.
[ ] Style: This PR adheres to the style guide.

Learn Build status updates of commit 4e18fb5:
:white_check_mark: Validation status: passed

File
Status
Preview URL
Details

.openpublishing.redirection.json
:white_check_mark:Succeeded

azps-9.0.1/Az.Accounts/Add-AzEnvironment.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Az.Accounts.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Clear-AzConfig.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Clear-AzContext.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Clear-AzDefault.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Connect-AzAccount.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Disable-AzContextAutosave.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Disable-AzDataCollection.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Disable-AzureRmAlias.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Disconnect-AzAccount.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Enable-AzContextAutosave.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Enable-AzDataCollection.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Enable-AzureRmAlias.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Export-AzConfig.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Get-AzAccessToken.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Get-AzConfig.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Get-AzContext.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Get-AzContextAutosaveSetting.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Get-AzDefault.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Get-AzEnvironment.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Get-AzSubscription.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Get-AzTenant.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Import-AzConfig.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

azps-9.0.1/Az.Accounts/Import-AzContext.md
:white_check_mark:Succeeded
n/a (file deleted or renamed)

This comment lists only the first 25 files in the pull request.
For more details, please refer to the build report.
Note: Broken links written as relative paths are included in the above build report. For broken links written as absolute paths or external URLs, see the broken link report.
For any questions, please:Try searching the learn.microsoft.com contributor guidesPost your question in the Learn support channel


Match @db:linkscope, not db:linkscope

This was fixed in https://github.com/docbook/transclusion-fixup/commit/69dac05420a790892cdf1e9d73920a1951e26355


Add more examples

Thanks for your work. A very interesting library.
Could you add more use cases if possible?

Elevated geometries (lines, polygons)
Svg markers
Dragging elements
Dynamic styling

hi @burkoyuriy , thanks for the feedback, we really appreciate people taking the time to comment.
What do you mean by elevated geometries? Do you want to have some lines / polygons overlaid on terrain? Or do you have some lines that have some elevation, such as the path of an aeroplane / satellite.
Regarding SVGs, we don't support this because we use an atlas when rendering the icons. i.e. we bake the SVG into an atlas file. But, for some special icons, we could consider to have SVGs.
Regarding dragging elements, what do you mean? Do you have some object that you want to, at the click of a button, pick up and move. This could be done on top of harp using a custom map object, but if there is enough demand, we could add some API.
Regarding dynamic styling, the functionality is available, just not for every parameter. We have an example where the colors change based on zoom, see: https://www.harp.gl/docs/master/examples/#styling_interpolation.html
Here: https://www.harp.gl/docs/master/examples/#datasource_geojson_styling_game.html is an example which shows a polygon being styled using dynamic-properties, these are values that you can changed in your application and are executed each frame before being rendered, hence dynamic


feat: adding new wallet config for latests sdk

Description
This PR fixes #255
Notes for Reviewers
Upgrading sdk and some configurations required for it to work
Signed commits

[ ] Yes, I signed my commits.

Nice, great fix.  Can we update the requirements.txt as well?  Worth looking at environment.yml too and making sure only what we need is in there.


chore: separate secret RBAC

What type of PR is this?
/kind flake
What this PR does / why we need it:
separate secret rbac
Which issue(s) this PR fixes:

Fixes #
Special notes for your reviewer:
Release note:

/test pull-blobfuse-csi-driver-e2e-vmss

/test pull-blobfuse-csi-driver-e2e-vmss


"typeRoots" and "types" options are not recognized.

Description
Typescript version is not 2 or higher -- some tsconfig options are not recognized. package.json seem to have right versions of both typescript and gulp-typescript. I did not change any of generated code.
Error Message & Stack Trace
[17:55:06] Using gulpfile ~/Documents/frontend/fountain_app/gulpfile.js
[17:55:06] Starting 'default'...
[17:55:06] Starting 'clean'...
[17:55:06] Finished 'clean' after 4.93 ms
[17:55:06] Starting 'build'...
[17:55:06] Starting 'partials'...
[17:55:06] Finished 'partials' after 58 ms
[17:55:06] Starting 'inject'...
[17:55:06] Starting 'other'...
[17:55:07] Starting 'styles'...
[17:55:07] Starting 'scripts'...
error TS5023: Unknown compiler option 'typeRoots'.
error TS5023: Unknown compiler option 'types'.
[17:55:07] Finished 'other' after 79 ms
[17:55:07] Finished 'styles' after 278 ms

There are many type errors after that -- I can add them if needed.
Config
{
  "generator-fountain-angular1": {
    "version": "1.0.0-rc2",
    "props": {
      "framework": "angular1",
      "modules": "inject",
      "js": "typescript",
      "ci": [],
      "css": "css",
      "resolved": "/usr/local/lib/node_modules/generator-fountain-webapp/node_modules/generator-fountain-angular1/generators/app/index.js",
      "namespace": "fountain-angular1",
      "argv": {
        "remain": [],
        "cooked": [],
        "original": []
      },
      "sample": "todoMVC",
      "router": "none"
    }
  }
}

Environment
Node.js v7.2.1
linux 4.4.0-53-generic
yo: 1.8.5
npm: 3.10.10

Thanks in advance!

I think I have found the reason: there are incompatibilities of typescript versions in gulp-typescript and typescript itself:
{
  "devDependencies": {
    ...
    "gulp-typescript": "^2.10.0",
    ...
    "typescript": "^2.1.0",
    ...
  },
...
}

gulp-typescript takes<EMAIL_ADDRESS>or something - that is why errors occure.
If you change version of gulp-typescript to 3.1.0 or higher, those error (and all typings error) will disappear.

same issue. your pills help me thanks!

same issue, but could not identify the module containing the old typescript version.


Relocate UnityCatalog AI integration examples to ai/ directory

PR Checklist

[X] A description of the changes is added to the description of this PR.
[ ] If there is a related issue, make sure it is linked to this PR.
[ ] If you've fixed a bug or added code that should be tested, add tests!
[ ] If you've added or modified a feature, documentation in docs is updated

Description of changes
We accidentally merged the example notebooks for anthropic and llamaindex to the legacy unitycatalog-ai directory. This moves them to where they should be.

@dennyglee I forgot to update the target locations on those sample notebooks! This moves them to the right spot. Thanks!


[WIP]: Add unit tests for Bitcoin specific strict_encoding

This is a draft of unit tests for strict_encoding as per #60.
As of now the tests only makes an encode-decode round trip and verifies the integrity of the decoded object.
Please suggest any form of optimization or missing test cases.
Will remove [WIP] tag when seems ready for merge.

Travis is failing at
error: component 'rustfmt' for target 'x86_64-unknown-linux-gnu' is unavailable for download for channel nightly
Sometimes not all components are available in any given nightly.
The command "./contrib/test.sh" exited with 1.

Which is not occurring at my local and it seem like a rust issue discussed here https://github.com/rust-lang/rustfmt/issues/3404

Yes, travis failure related to rust itself and it will be fixed only with the next nightly release

Updated as per the review. This PR is now ready for 2nd look.

As for garbage, I think PubKey, Signature and OutPoints are enough

Added garbage tests for signature, pubkey and outpiont. They check for UnexpectedEof for now. If that's inadequate and other checks are needed will update accordingly.

Added DataIntegrityError garbage test for pubkey.


[Integration] Edits to the conversations list in compare mode

Icon size is 18 px
Let's show the conversation name on one line with dots at the end

Figma: https://www.figma.com/file/lwL5jneveZczAj5RLcLFH2/DIAL-Chat?type=design&node-id=249%3A8205&mode=design&t=BdqR07Mf0Mjtk9NE-1

[Volha] It's not a rare case to have chats with long name (created automatically). These chats in Compare mode look in the following way:

Verified on UAT server, now the chat name is cut in the list, but reported #1037


show message in embed

Solves #3

This is a good PR. Thank you!

This is a good PR. Thank you!

ok

ok


Deprecate Form

Issue Description
It's been found that terra-form needs to be better broken up, as a change to any component could cause several major version bumps for each component that needs to be changed. To resolve this, form needs to be deprecated so that consumers know to use the new form packages. We should do the following

Provide links to the new component on the individual pages
Provide a message on the root documentation page for terra-form.

Issue Type

[ ] New Feature
[ ] Enhancement
[ ] Bug
[x] Other

Provide links to the new component on the individual pages

The doc pages no longer exist for the terra-form package

Provide a message on the root documentation page for terra-form.

This package no longer exists in the repo.
We have however posted internally and to our MSTeams channel about the deprecation and migration guide. Based on that I'd consider this issue done.


Static variable Not followed the naming convention

https://github.com/alibaba/testable-mock/blob/f660ccb88fb18b0dc30649a1b35aad9bbb43e73f/testable-agent/src/main/java/com/alibaba/testable/agent/PreMain.java#L21
Static variable Not followed the naming convention, please address it.

As I know, final variable usually prone to be defined in underscored-uppercase letters, is there a naming convention for static variable ?

looks good according to:
https://www.oracle.com/java/technologies/javase/codeconventions-namingconventions.html


How to get a group id?

We can use the suggested_groups method to get information about groups, including their unique identifiers.
However how can we get the identifier of any group if we know it's name or slug?
Trying to get the group id for use with the group_posts method.

Oh awesome, you can use the search method with a searchtype of "groups". I had been trying "group". This isn't documented anywhere! We should document this. Will add some docstring in #41

Thanks! It is in the readme fwiw, but if you're using it as an API I can see why that would be missed.


⚠ Bofrost.be has degraded performance

In 60b4db6, Bofrost.be (https://www.bofrost.be) experienced degraded performance:

HTTP code: 200
Response time: 1446 ms

Resolved: Bofrost.be performance has improved in 6862f19.


Integrate spectra calculator for moist baro wave ex

This PR will close #994
Purpose
Integrate the use of ClimaCoreSpectra for spectra calculation in ClimaAtmos.
Will close #994 .
Content
Add spectrum calculations in the AMIP driver/postprocessing pipeline. The test case used for initial integration example is moist baroclinic wave. The intent is to replicate the existing behavior in ClimateMachine

Solution implemented as in the ClimateMachine implementation.

Review checklist
I have:

[x] followed the codebase contribution guide: https://clima.github.io/ClimateMachine.jl/latest/Contributing/
[x] followed the style guide: https://clima.github.io/ClimateMachine.jl/latest/DevDocs/CodeStyle/
[x] followed the documentation policy: https://github.com/CliMA/policies/wiki/Documentation-Policy
[x] checked that this PR does not duplicate an open PR.

bors try

bors try

bors try

@jiahe23 do you have any more questions/comments/review? Thanks

@jiahe23 do you have any more questions/comments/review? Thanks

Could you add comments to the hard-coded index in case we forget again later? Otherwise it looks good to me.
BTW, is the latest CC working fine with hdf5 now?

Could you add comments to the hard-coded index in case we forget again later? Otherwise it looks good to me.

Done.

BTW, is the latest CC working fine with hdf5 now?
I am not aware of any issues but maybe I was out of the loop in that regard

Branches are becoming stale really fast (I had to rebase onto main 3 times in the last half an hour), so if this is satisfactory, can I get an approval please so that we can merge it? Thanks

bors r+

bors r+


New functions DetectSerialPort() and GetSerialPorts()

Previously found in internal/util in -apps, slightly changed to be a little less verbose.

Merged.


Feature Request: Support for HTTP Redirect (Status 3xx)

It would be useful to have support for redirects like 3xx HTTP status.
According to WebSocket Protocol Specification from IETF, clients are not required to follow redirects, but they may do it. So this could probably be a feature that can be switched on/off with a boolean or so :)
Quote from https://tools.ietf.org/html/rfc6455:
   1.  If the status code received from the server is not 101, the
       client handles the response per HTTP [RFC2616] procedures.  In
       particular, the client might perform authentication if it
       receives a 401 status code; the server might redirect the client
       using a 3xx status code (but clients are not required to follow
       them), etc.  Otherwise, proceed as follows.

Has this potentially changed since 2018?


Myst parser does not handle the code-cell directive

A code-cell directive is used in MyST notebook.
This is defined here in the jupyterbook docs in terms of converting from .ipynb  to MyST .md using juyptertext that appears to be where code-cell is defined?
currently mysjs does not parse this directive, byt myst-nb does. Being able to parse and support existing MyST notebooks would be very cool.

This probably also means extending the docs in terms of adding a subsection on the directive, and a section on working with MyST notebooks. In fact, if this is a migration pathway for people onto the js cli, then perhaps there should be a guide?

This was released in 0.1.18! 🚀


'NoneType' object has no attribute 'dtype'

I am getting this error when trying to convert the audio file.
Traceback (most recent call last):
File "E:\RVC-beta-v2-0528\runtime\lib\site-packages\gradio\routes.py", line 321, in run_predict
output = await app.blocks.process_api(
File "E:\RVC-beta-v2-0528\runtime\lib\site-packages\gradio\blocks.py", line 1007, in process_api
data = self.postprocess_data(fn_index, result["prediction"], state)
File "E:\RVC-beta-v2-0528\runtime\lib\site-packages\gradio\blocks.py", line 953, in postprocess_data
prediction_value = block.postprocess(prediction_value)
File "E:\RVC-beta-v2-0528\runtime\lib\site-packages\gradio\components.py", line 2076, in postprocess
processing_utils.audio_to_file(sample_rate, data, file.name)
File "E:\RVC-beta-v2-0528\runtime\lib\site-packages\gradio\processing_utils.py", line 206, in audio_to_file
data = convert_to_16_bit_wav(data)
File "E:\RVC-beta-v2-0528\runtime\lib\site-packages\gradio\processing_utils.py", line 219, in convert_to_16_bit_wav
if data.dtype in [np.float64, np.float32, np.float16]:
AttributeError: 'NoneType' object has no attribute 'dtype'

Mine too.
Traceback (most recent call last):
File "C:\001-RVC0813Nvidia\infer-web.py", line 195, in vc_single
if_f0 = cpt.get("f0", 1)
AttributeError: 'NoneType' object has no attribute 'get'
and
Traceback (most recent call last):
File "C:\001-RVC0813Nvidia\infer-web.py", line 276, in vc_multi
paths = [os.path.join(dir_path, name) for name in os.listdir(dir_path)]
FileNotFoundError: [WinError 3] The system cannot find the path specified: 'E:\codes\py39\test-20230416b\todo-songs'
and
Traceback (most recent call last):
File "C:\001-RVC0813Nvidia\infer-web.py", line 276, in vc_multi
paths = [os.path.join(dir_path, name) for name in os.listdir(dir_path)]
NotADirectoryError: [WinError 267] The directory name is invalid: 'C:\atl-instrumeno\weightless-atl.mp3'

Anyone find a solution for this yet?

It appears that the problem is specific to this particular trained model. I've experimented with other models I've trained, and they function as expected. However, I'm still in the process of pinpointing the exact issue.

Anyone find a solution for this yet?

There is none and there will never be one. Tis the way of RVC

ok.. I think i solved it...
two things:

make sure the file you are trying to sound like is saved as a 16bit wav (not 24 bit or 32 bit float etc)
2)end your file name path with .wav  ( i only added it to the name of the path and not renamed in my directory)

this fixed my issues...

ok.. I think i solved it...
two things:

make sure the file you are trying to sound like is saved as a 16bit wav (not 24 bit or 32 bit float etc)
2)end your file name path with .wav  ( i only added it to the name of the path and not renamed in my directory)

this fixed my issues...

Thanks , This fixed my issue as well.

Can you explain this wav thing? I'm having this issue, but here's the wheird thing. It only happens if using a gpu, If I use my cpu, everything runs smoothly and I can give it whatever file format I like. Thanks


Add zone to kv options

@xichen2020

Coverage decreased (-0.1%) to 83.112% when pulling c23d6bf3b640e16487567e3e4d09b576311e2177 on chao-zone into 867ebcf21f264879be2d01d315d548f6786625c5 on master.


Too many files open error

I have encountered the error "Too many files open", when working on datasets greater than 1000. I believe the error occur in the following line
I cannot see the needs for creating multiple different files, why not instead create a single file, which you can keep reading/writing (and afterwards delete it).

Hi @AndreasHolm,
if I use mail-parser in multiprocesses tool and I don't use that function, I have a contention issue.
After conversion I use the result to analyze the raw mail and then I remove it:
https://github.com/SpamScope/mail-parser/blob/develop/mailparser/mailparser.py#L177
So I need to reproduce the error, can you help me?

You can simply reproduce the error by looping over e.g. parse_from_file_msg, until your OS can't handle more open files, it will then throw the error "Too many open files". If needed I can provide a script that will throw this error.

Ok, send me your snippet.

Okay, I will make the a snippet for you one of the following days. But from the snippet you send, you call the Perl script in a bash script, the problem lies within the python wrapper.
Specifically the following call "temp = tempfile.mkstemp(prefix="outlook_")[-1]", this creates a tmp file, but it is never closed properly, and the python instance will keep the files open until the OS can't handle more open files (mine can also handle 1024 per process).

Without any testing, this snippet should produce the error:
[mailparser.parse_from_file_msg(PATH_TO_MAIL) for _ in range(2000)]

I started a test and checked with lsof:
ipython     913   947   fedelemantuano  185u      REG              254,5    181678        209 /tmp/outlook_1tMvBT (deleted)
ipython     913   947   fedelemantuano  186u      REG              254,5    181679        210 /tmp/outlook_kT3NdF (deleted)
ipython     913   947   fedelemantuano  187u      REG              254,5    181695        211 /tmp/outlook_8yMzjn (deleted)

The deleted operation is here and it's not released.
I have to understand why?
Can you have some idea?

The problem as I see it, is that you create and open the tmp file, but while you open it you discard the file descriptor, such that you can never close it. Looking at the faulty code I would change it to something like the following:
fd, tmp = tempfile.mkstemp(prefix='outlook_')
When you have the filedescriptor you can close it with:
os.close(fd),
when you are finished writing to the file.
By doing a little google search, I found someone who had the exact same problem: https://stackoverflow.com/questions/9944135/how-do-i-close-the-files-from-tempfile-mkstemp

@AndreasHolm, can you test last version?
From my tests I solved the bug.

Seems to be working at my end too.


Checklist

[x] PR has an informative and human-readable title
[x] Changes are limited to a single goal (no scope creep)
[x] Code follows the standards laid out in the CFPB development guidelines

For once I'm trying to follow our PR guidelines!

Changes are limited to a single goal (no scope creep)


Clicking anywhere on the blog post (including the description) should open it in new tab

Right now only clicking on the title, button or img opens the blog.
Wrap the entire thing in a link

Hello @ihsavru, can I contribute to this?


[Bug]: Qwen2 Moe FP8 not supported on L40

Your current environment
Collecting environment information...
PyTorch version: 2.3.0+cu121
Is debug build: False
CUDA used to build PyTorch: 12.1
ROCM used to build PyTorch: N/A

OS: Ubuntu 22.04.3 LTS (x86_64)
GCC version: Could not collect
Clang version: Could not collect
CMake version: version 3.30.0
Libc version: glibc-2.35

Python version: 3.11.9 (main, Apr 19 2024, 16:48:06) [GCC 11.2.0] (64-bit runtime)
Python platform: Linux-5.4.241-1-tlinux4-0017.6-x86_64-with-glibc2.35
Is CUDA available: True
CUDA runtime version: Could not collect
CUDA_MODULE_LOADING set to: LAZY
GPU models and configuration:
GPU 0: NVIDIA L40
GPU 1: NVIDIA L40

Nvidia driver version: 535.161.07
cuDNN version: Could not collect
HIP runtime version: N/A
MIOpen runtime version: N/A
Is XNNPACK available: True

CPU:
Architecture:                    x86_64
CPU op-mode(s):                  32-bit, 64-bit
Address sizes:                   52 bits physical, 48 bits virtual
Byte Order:                      Little Endian
CPU(s):                          384
On-line CPU(s) list:             0-383
Vendor ID:                       AuthenticAMD
Model name:                      AMD EPYC 9K84 96-Core Processor
CPU family:                      25
Model:                           17
Thread(s) per core:              2
Core(s) per socket:              96
Socket(s):                       2
Stepping:                        0
BogoMIPS:                        5200.06
Flags:                           fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ht syscall nx mmxext fxsr_opt pdpe1gb rdtscp lm
 rep_good nopl cpuid extd_apicid amd_dcm tsc_known_freq pni pclmulqdq ssse3 fma cx16 pcid sse4_1 sse4_2 x2apic movbe popcnt tsc_deadline_timer aes xsave avx f16c rdrand hyperviso
r lahf_lm cmp_legacy cr8_legacy abm sse4a misalignsse 3dnowprefetch osvw topoext perfctr_core invpcid_single ibpb vmmcall fsgsbase tsc_adjust bmi1 avx2 smep bmi2 erms invpcid avx
512f avx512dq rdseed adx smap avx512ifma clflushopt clwb avx512cd sha_ni avx512bw avx512vl xsaveopt xsavec xgetbv1 avx512_bf16 clzero xsaveerptr wbnoinvd arat avx512vbmi umip avx
512_vbmi2 vaes vpclmulqdq avx512_vnni avx512_bitalg avx512_vpopcntdq rdpid fsrm
Hypervisor vendor:               KVM
Virtualization type:             full
L1d cache:                       6 MiB (192 instances)
L1i cache:                       6 MiB (192 instances)
L2 cache:                        192 MiB (192 instances)
L3 cache:                        768 MiB (24 instances)
NUMA node(s):                    2
NUMA node0 CPU(s):               0-191
NUMA node1 CPU(s):               192-383
Vulnerability Itlb multihit:     Not affected
Vulnerability L1tf:              Not affected
Vulnerability Mds:               Not affected
Vulnerability Meltdown:          Not affected
Vulnerability Mmio stale data:   Not affected
Vulnerability Retbleed:          Not affected
Vulnerability Spec store bypass: Vulnerable
Vulnerability Spectre v1:        Vulnerable: __user pointer sanitization and usercopy barriers only; no swapgs barriers
Vulnerability Spectre v2:        Vulnerable, IBPB: disabled, STIBP: disabled, PBRSB-eIBRS: Not affected
Vulnerability Srbds:             Not affected
Vulnerability Tsx async abort:   Not affected

Versions of relevant libraries:
[pip3] numpy==1.26.4
[pip3] nvidia-nccl-cu12==2.20.5
[pip3] torch==2.3.0
[pip3] torchvision==0.18.0
[pip3] transformers==4.42.3
[pip3] triton==2.3.0
[conda] Could not collect
ROCM Version: Could not collect
Neuron SDK Version: N/A
vLLM Version: 0.5.1
vLLM Build Flags:
CUDA Archs: Not Set; ROCm: Disabled; Neuron: Disabled
GPU Topology:
GPU0    GPU1    CPU Affinity    NUMA Affinity   GPU NUMA ID
GPU0     X      NODE    0-191   0               N/A
GPU1    NODE     X      0-191   0               N/A

Legend:

  X    = Self
  SYS  = Connection traversing PCIe as well as the SMP interconnect between NUMA nodes (e.g., QPI/UPI)
  NODE = Connection traversing PCIe as well as the interconnect between PCIe Host Bridges within a NUMA node
  PHB  = Connection traversing PCIe as well as a PCIe Host Bridge (typically the CPU)
  PXB  = Connection traversing multiple PCIe bridges (without traversing the PCIe Host Bridge)
  PIX  = Connection traversing at most a single PCIe bridge
  NV#  = Connection traversing a bonded set of # NVLinks

🐛 Describe the bug
After loading a fp8 qwen2 moe model
 python -m vllm.entrypoints.openai.api_server   --model ./moe   --port 8081   --host 0.
0.0.0   --trust-remote-code   --tensor-parallel-size 2
INFO 07-09 12:19:33 api_server.py:206] vLLM API server version 0.5.1
INFO 07-09 12:19:33 api_server.py:207] args: Namespace(host='<IP_ADDRESS>', port=8081, uvicorn_log_level='info', allow_credentials=False, allowed_origins=['*'], allowed_methods=['*'],
 allowed_headers=['*'], api_key=None, lora_modules=None, chat_template=None, response_role='assistant', ssl_keyfile=None, ssl_certfile=None, ssl_ca_certs=None, ssl_cert_reqs=0, r
oot_path=None, middleware=[], model='./moe', tokenizer=None, skip_tokenizer_init=False, revision=None, code_revision=None, tokenizer_revision=None, tokenizer_mode='auto', trust_r
emote_code=True, download_dir=None, load_format='auto', dtype='auto', kv_cache_dtype='auto', quantization_param_path=None, max_model_len=None, guided_decoding_backend='outlines',
 distributed_executor_backend=None, worker_use_ray=False, pipeline_parallel_size=1, tensor_parallel_size=2, max_parallel_loading_workers=None, ray_workers_use_nsight=False, block
_size=16, enable_prefix_caching=False, disable_sliding_window=False, use_v2_block_manager=False, num_lookahead_slots=0, seed=0, swap_space=4, gpu_memory_utilization=0.9, num_gpu_
blocks_override=None, max_num_batched_tokens=None, max_num_seqs=256, max_logprobs=20, disable_log_stats=False, quantization=None, rope_scaling=None, rope_theta=None, enforce_eage
r=False, max_context_len_to_capture=None, max_seq_len_to_capture=8192, disable_custom_all_reduce=False, tokenizer_pool_size=0, tokenizer_pool_type='ray', tokenizer_pool_extra_con
fig=None, enable_lora=False, max_loras=1, max_lora_rank=16, lora_extra_vocab_size=256, lora_dtype='auto', long_lora_scaling_factors=None, max_cpu_loras=None, fully_sharded_loras=
False, device='auto', scheduler_delay_factor=0.0, enable_chunked_prefill=False, speculative_model=None, num_speculative_tokens=None, speculative_draft_tensor_parallel_size=None,
speculative_max_model_len=None, speculative_disable_by_batch_size=None, ngram_prompt_lookup_max=None, ngram_prompt_lookup_min=None, spec_decoding_acceptance_method='rejection_sam
pler', typical_acceptance_sampler_posterior_threshold=None, typical_acceptance_sampler_posterior_alpha=None, model_loader_extra_config=None, preemption_mode=None, served_model_na
me=None, qlora_adapter_name_or_path=None, otlp_traces_endpoint=None, engine_use_ray=False, disable_log_requests=False, max_log_len=None)
INFO 07-09 12:19:33 config.py:698] Defaulting to use mp for distributed inference
INFO 07-09 12:19:33 llm_engine.py:169] Initializing an LLM engine (v0.5.1) with config: model='./moe', speculative_config=None, tokenizer='./moe', skip_tokenizer_init=False, toke
nizer_mode=auto, revision=None, rope_scaling=None, rope_theta=None, tokenizer_revision=None, trust_remote_code=True, dtype=torch.float16, max_seq_len=16384, download_dir=None, lo
ad_format=LoadFormat.AUTO, tensor_parallel_size=2, pipeline_parallel_size=1, disable_custom_all_reduce=False, quantization=fp8, enforce_eager=False, kv_cache_dtype=auto, quantiza
tion_param_path=None, device_config=cuda, decoding_config=DecodingConfig(guided_decoding_backend='outlines'), observability_config=ObservabilityConfig(otlp_traces_endpoint=None),
 seed=0, served_model_name=./moe, use_v2_block_manager=False, enable_prefix_caching=False)
WARNING 07-09 12:19:34 tokenizer.py:126] Using a slow tokenizer. This might cause a significant slowdown. Consider using a fast tokenizer instead.
(VllmWorkerProcess pid=22996) INFO 07-09 12:19:34 multiproc_worker_utils.py:215] Worker ready; awaiting tasks
(VllmWorkerProcess pid=22996) INFO 07-09 12:19:35 utils.py:741] Found nccl from library libnccl.so.2
INFO 07-09 12:19:35 utils.py:741] Found nccl from library libnccl.so.2
INFO 07-09 12:19:35 pynccl.py:63] vLLM is using nccl==2.20.5
(VllmWorkerProcess pid=22996) INFO 07-09 12:19:35 pynccl.py:63] vLLM is using nccl==2.20.5
INFO 07-09 12:19:35 custom_all_reduce_utils.py:232] reading GPU P2P access cache from /root/.config/vllm/gpu_p2p_access_cache_for_0,1.json
(VllmWorkerProcess pid=22996) INFO 07-09 12:19:35 custom_all_reduce_utils.py:232] reading GPU P2P access cache from /root/.config/vllm/gpu_p2p_access_cache_for_0,1.json
WARNING 07-09 12:19:35 fp8.py:45] Detected fp8 checkpoint. Please note that the format is experimental and subject to change.
(VllmWorkerProcess pid=22996) WARNING 07-09 12:19:35 fp8.py:45] Detected fp8 checkpoint. Please note that the format is experimental and subject to change.
(VllmWorkerProcess pid=22996) INFO 07-09 12:21:45 model_runner.py:255] Loading model weights took 8.0809 GB
INFO 07-09 12:21:46 model_runner.py:255] Loading model weights took 8.0809 GB
Conversion from/to f8e4m3nv is only supported on compute capability >= 90

UNREACHABLE executed at /project/lib/Conversion/TritonGPUToLLVM/ElementwiseOpToLLVM.cpp:823!
Conversion from/to f8e4m3nv is only supported on compute capability >= 90

UNREACHABLE executed at /project/lib/Conversion/TritonGPUToLLVM/ElementwiseOpToLLVM.cpp:823!
/home/qspace/data/mmsprwelmmodelsvra/rce2004389934/vllm/lib/python3.11/multiprocessing/resource_tracker.py:254: UserWarning: resource_tracker: There appear to be 2 leaked shared_
memory objects to clean up at shutdown
  warnings.warn('resource_tracker: There appear to be %d '
Aborted (core dumped)

The config.json is
{
  "_name_or_path": "/data/home/yowenchen/vllm/model_qwen_moe",
  "architectures": [
    "Qwen2MoeForCausalLM"
  ],
  "attention_dropout": 0,
  "decoder_sparse_step": 1,
  "eos_token_id": 2,
  "hidden_act": "silu",
  "hidden_size": 2048,
  "initializer_range": 0.02,
  "intermediate_size": 1408,
  "max_position_embeddings": 16384,
  "max_window_layers": 28,
  "mlp_only_layers": [],
  "model_type": "qwen2_moe",
  "moe_intermediate_size": 1408,
  "norm_topk_prob": true,
  "num_attention_heads": 16,
  "num_experts": 64,
  "num_experts_per_tok": 6,
  "num_hidden_layers": 28,
  "num_key_value_heads": 16,
  "output_router_logits": false,
  "quantization_config": {
    "activation_scheme": "dynamic",
    "quant_method": "fp8"
  },
  "rms_norm_eps": 1e-05,
  "rope_theta": 10000.0,
  "router_aux_loss_coef": 0.001,
  "shared_expert_intermediate_size": 2816,
  "sliding_window": 4096,
  "tie_word_embeddings": false,
  "torch_dtype": "float16",
  "transformers_version": "4.41.2",
  "use_cache": true,
  "use_sliding_window": false,
  "vocab_size": 102400
}

fp8 not yet supported for Qwen. WIP PR: https://github.com/vllm-project/vllm/pull/6088

fp8 not yet supported for Qwen. WIP PR: #6088

@robertgshaw2-neuralmagic Hello, the error still exists in version 0.5.3 .

Fp8 is now supported for Qwen, but requires compute_capability == 9.0 (aka Hopper GPUs)
Our MoE kernels are currently implemented using Triton, which require triton==3.0 for Fp8 on Ada Lovelace. We are limited by PyTorch's version of triton
We look forward to supporting Fp8 MoE on Ada Lovelace once these dependencies are enabled


View/Edit Yaml does not work

What kind of request is this (question/bug/enhancement/feature request): bug
Steps to reproduce (least amount of steps as possible):

Deploy a workload
Do a View/Edit Yaml when the workload is Active
Error on UI:

Error seen in Network tab of dev console: 404 Not Found

Expected Result:
User should be able to View/Edit yaml of the workload
Other details that may be helpful:
Happens for an ingress/HPA also.
Environment information

Rancher version (rancher/rancher/rancher/server image tag or shown bottom left in the UI): 2.5-head commit id: 03b815317
Installation option (single install/HA): single

Cluster information

Cluster type (Hosted/Infrastructure Provider/Custom/Imported): DO rke
Kubernetes version (use kubectl version):

1.20

Docker version (use docker version):

20.10

I presume this is from using K8s 1.20 and the new lack of a self link.

I see this working on a 1.19k8s cluster and see the issue on a 1.20 k8s cluster.

Verified on master-head - commit id: 1ee983f4

Deploy a workload
Do a View/Edit Yaml when the workload is Active
View/Edit Yaml works


Adding a button on steven multi select

How can i add a button through which i can open and close the drop down?

By default it doesn't support such thing, but you can try to use "directive-id", and then find the element with class "checkboxLayer", add class "show" so it becomes "checkboxLayer  show".

@rajaEmani  do you want a separate button that should open dropdown from outside isteven? Would you mind to elaborate the scenario, I'd love to help you on this. If you want you can also consider adding Stackoverflow question and add link here.

@pankajparkar yes I want a separate button that should open dropdown from outside isteven. Please help me out on this

Can you please share a plunker with what you have tried so far?

I have seen your code.
Thanks,
Can you please show to how to add that event to an external button?

@pankajparkar Any update on this or should I raise a stack over flow for you?

@rajaEmani primarily I'd need plunker/fiddle with problem replication in it. So that I can try out stuff and would able make something work on it.


ocamlPackages.nonstd: fix fetch error by using fetchzip

Motivation for this change
fetchFromBitbucket got confused with unpacking the archive apparently, so we use fetchzip and the archive listed in the opam repository.
Things done

[x] Tested using sandboxing (nix.useSandbox on NixOS, or option sandbox in nix.conf on non-NixOS linux)
Built on platform(s)

[x] NixOS
[ ] macOS
[ ] other Linux distributions

[ ] Tested via one or more NixOS test(s) if existing and applicable for the change (look inside nixos/tests)
[ ] Tested compilation of all pkgs that depend on this change using nix-shell -p nixpkgs-review --run "nixpkgs-review wip"
[ ] Tested execution of all binary files (usually in ./result/bin/)
[ ] Determined the impact on package closure size (by running nix path-info -S before and after)
[ ] Ensured that relevant documentation is up to date
[x] Fits CONTRIBUTING.md.

@GrahamcOfBorg build ocamlPackages.genspio

@GrahamcOfBorg build ocamlPackages.genspio

Thanks.

Thanks.


Use responsive col-sm-4 on homepage

Bootstrap's col-xs-* classes are always rendered horizontally - the stats and issues columns were causing smartphone-sized displays to break the rest of the layout:

I switched them to col-sm , which stacks them vertically for "xs"-sized devices and goes back to horizontal for larger ones.
I used http://getbootstrap.com/css/#grid-options for reference.

Thanks @zekeweeks!! I was meaning to do something like that...