[Container Plumbing Days 2023] Why was nerdctl made?Akihiro Suda
nerdctl (contaiNERD CTL) was made to facilitate development of new technologies in the containerd platform.
Such technologies include:
- Lazy-pulling with Stargz/Nydus/OverlayBD
- P2P image distribution with IPFS
- Image encryption with OCIcrypt
- Image signing with Cosign
- “Real” read-only mounts with mount_setattr
- Slirp-less rootless containers with bypass4netns
- Interactive debugging of Dockerfiles, with buildg
nerdctl is also useful for debugging Kubernetes nodes that are running containerd.
Through this session, the audiences will learn these functionalities of nerdctl, relevant projects, and the roadmap for the future.
https://containerplumbing.org/sessions/2023/why_was_nerdctl_
Introducing Cisco HyperFlex Systems: The Next Generation in Complete Hypercon...Cisco Canada
Initial hyperconverged solutions brought new levels of IT simplicity, as well as the associated speed. However, quickly increasing simplicity came at a price and design trade-offs were made limiting infrastructure agility, efficiency, and adaptability.
Introducing Cisco HyperFlex Systems, complete hyperconvergence that unifies Cisco networking and computing technology with the next-generation Cisco HX Data Platform. Powered by the Cisco Unified Computing System (Cisco UCS) platform, Cisco HyperFlex solutions deliver new levels of operational efficiency and adaptability to more workloads and applications. Cisco HyperFlex technology answers the operations requirements for agility, scalability, and pay-as-you-grow economics of the cloud—but with the benefits of on-premises infrastructure.
Agenda:
• New innovations to the Cisco data center portfolio
• Introducing Cisco HyperFlex Systems powered by the Cisco UCS platform
• Deep dive into the Cisco HyperFlex HX Data Platform
• Preview early deployments of Cisco HyperFlex Systems
[Container Plumbing Days 2023] Why was nerdctl made?Akihiro Suda
nerdctl (contaiNERD CTL) was made to facilitate development of new technologies in the containerd platform.
Such technologies include:
- Lazy-pulling with Stargz/Nydus/OverlayBD
- P2P image distribution with IPFS
- Image encryption with OCIcrypt
- Image signing with Cosign
- “Real” read-only mounts with mount_setattr
- Slirp-less rootless containers with bypass4netns
- Interactive debugging of Dockerfiles, with buildg
nerdctl is also useful for debugging Kubernetes nodes that are running containerd.
Through this session, the audiences will learn these functionalities of nerdctl, relevant projects, and the roadmap for the future.
https://containerplumbing.org/sessions/2023/why_was_nerdctl_
Introducing Cisco HyperFlex Systems: The Next Generation in Complete Hypercon...Cisco Canada
Initial hyperconverged solutions brought new levels of IT simplicity, as well as the associated speed. However, quickly increasing simplicity came at a price and design trade-offs were made limiting infrastructure agility, efficiency, and adaptability.
Introducing Cisco HyperFlex Systems, complete hyperconvergence that unifies Cisco networking and computing technology with the next-generation Cisco HX Data Platform. Powered by the Cisco Unified Computing System (Cisco UCS) platform, Cisco HyperFlex solutions deliver new levels of operational efficiency and adaptability to more workloads and applications. Cisco HyperFlex technology answers the operations requirements for agility, scalability, and pay-as-you-grow economics of the cloud—but with the benefits of on-premises infrastructure.
Agenda:
• New innovations to the Cisco data center portfolio
• Introducing Cisco HyperFlex Systems powered by the Cisco UCS platform
• Deep dive into the Cisco HyperFlex HX Data Platform
• Preview early deployments of Cisco HyperFlex Systems
Git, CMake, Conan - How to ship and reuse our C++ projects?Mateusz Pusz
These are the slides from my CppCon 2018 talk. You can find the recording here: https://www.youtube.com/watch?v=S4QSKLXdTtA. All my other talks can be found here: https://train-it.eu/resources.
---
Git and CMake are already established standards in our community. However, it is uncommon to see them being used in an efficient way. As a result, many C++ projects have big problems with either importing other dependencies or making themselves easy to import by others. It gets even worse when we need to build many different configurations of our package on one machine.
That presentation lists and addresses the problems of build system and packaging that we have with large, multi-platform, C++ projects that often have many external and internal dependencies. The talk will present how proper use of CMake and Conan package manager can address those use cases. It will also describe current issues with the cooperation of those tools.
If you've attended or seen my talk at C++Now 2018, that time you can expect much more information on Conan and package creation using that tool. I will also describe how the integration of CMake and Conan changed over the last few months.
Shell: A Command-Line Interpretor that connects a user to Operating System and allows to execute the commands or by creating text script.
Process: Any task that a user run in the system is called a process. A process is little more complex than just a task.
File: It resides on hard disk (hdd) and contains data owned by a user.
X-windows aka windows: A mode of Linux where screen (monitor) can be split in small “parts” called windows, that allow a user to do several things at the same time and/or switch from one task to another easily and view graphics in a nice way.
Text terminal: A monitor that has only the capability of displaying text stuff, no graphics or a very basic graphics display.
Session: Time between logging on and logging out of the system.
Part 02 Linux Kernel Module ProgrammingTushar B Kute
Presentation on "Linux Kernel Module Programming".
Presented at Army Institute of Technology, Pune for FDP on "Basics of Linux Kernel Programming". by Tushar B Kute (http://tusharkute.com).
This is the slide deck I presented at the first CommCon event in the UK: it goes through some of the possible strategies for scaling WebRTC applications, mostly if you're using Janus but not only.
Embedded Recipes 2018 - Finding sources of Latency In your system - Steven Ro...Anne Nicolas
Having just an RTOS is not enough for a real-time system. The hardware must be deterministic as well as the applications that run on the system. When you are missing deadlines, the first thing that must be done is to find what is the source of the latency that caused the issue. It could be the hardware, the operating system or the application, or even a combination of the above. This talk will discuss how to determine where the latency is using tools that come with the Linux Kernel, and will explain a few cases that caused issues.
Tutorial: Using GoBGP as an IXP connecting routerShu Sugimoto
- Show you how GoBGP can be used as a software router in conjunction with quagga
- (Tutorial) Walk through the setup of IXP connecting router using GoBGP
This lecture Introduces how Linux Handles Input and Output of its processes. It discusses the TTY/PTY devices and different types of terminals (Physical Terminal, Virtual Terminals, and Emulated Terminals)
Check the other Lectures and courses in
http://Linux4EnbeddedSystems.com
or Follow our Facebook Group at
- Facebook: @LinuxforEmbeddedSystems
Lecturer Profile:
- https://www.linkedin.com/in/ahmedelarabawy
Linux offers an extensive selection of programmable and configurable networking components from traditional bridges, encryption, to container optimized layer 2/3 devices, link aggregation, tunneling, several classification and filtering languages all the way up to full SDN components. This talk will provide an overview of many Linux networking components covering the Linux bridge, IPVLAN, MACVLAN, MACVTAP, Bonding/Team, OVS, classification & queueing, tunnel types, hidden routing tricks, IPSec, VTI, VRF and many others.
FUSE and beyond: bridging filesystems slides by Emmanuel Dreyfuseurobsdcon
Abstract
Everything started with the desire to have a distributed filesystem better than NFS, which would be elastic and replicated with no SPOF. glusterFS was among the filesystems that could do that, but it uses The FUSE interface to the kernel, which was not available on NetBSD.
We will therefore discuss FUSE implementation and its NetBSD counterpart which is called PUFFS. A first but isufficient bridging attmpt called reFUSE was done, but porting real filesystems required the more complete PERFUSE bridge, which we will present here.
In a third part, we will look at the various unexpected roadblocks that had to be handled during PERFUSE implementation, in order to get a fully functionnal glusterFS on NetBSD.
Speaker bio
Emmanuel Dreyfus works as an IT manager at ESPCI ParisTech in France. He has been contributing for 13 years to NetBSD, in areas such as binary compatibility, and FUSE implementation. More at http://hcpnet.free.fr/pubz/
ABB are a leading manufacturer of medium voltage (MV) fuses used as main or back up protection elements of systems and apparatus. Fuses (commonly recognized as High Voltage Fuses) are classified as current limiting and non-current limiting (expulsion).
ABB fuses are designed based on wide application experience coming from designing of electrical protection in medium voltage systems and coordination with ABB products where fuses are applicable (air and SF6 insulated switchgears with load break switches, distribution transformers and contactors).
ABB MV HV medium-high voltage fuses protect distribution transformers, motors, switchgear and capacitor banks against overload currents - ABB MV-HV fuses can operate as sole devices or can be combined with air/SF6 insulated switch disconnectors. T&D distribute ABB medium voltage fuses for safe protection of 3.3kV, 6.6kV, 7.2kV, 11kV, 12kV 15kV, 20kV, 22kV, 24kV, 33kV, 36kV and 42kV cable systems.
Git, CMake, Conan - How to ship and reuse our C++ projects?Mateusz Pusz
These are the slides from my CppCon 2018 talk. You can find the recording here: https://www.youtube.com/watch?v=S4QSKLXdTtA. All my other talks can be found here: https://train-it.eu/resources.
---
Git and CMake are already established standards in our community. However, it is uncommon to see them being used in an efficient way. As a result, many C++ projects have big problems with either importing other dependencies or making themselves easy to import by others. It gets even worse when we need to build many different configurations of our package on one machine.
That presentation lists and addresses the problems of build system and packaging that we have with large, multi-platform, C++ projects that often have many external and internal dependencies. The talk will present how proper use of CMake and Conan package manager can address those use cases. It will also describe current issues with the cooperation of those tools.
If you've attended or seen my talk at C++Now 2018, that time you can expect much more information on Conan and package creation using that tool. I will also describe how the integration of CMake and Conan changed over the last few months.
Shell: A Command-Line Interpretor that connects a user to Operating System and allows to execute the commands or by creating text script.
Process: Any task that a user run in the system is called a process. A process is little more complex than just a task.
File: It resides on hard disk (hdd) and contains data owned by a user.
X-windows aka windows: A mode of Linux where screen (monitor) can be split in small “parts” called windows, that allow a user to do several things at the same time and/or switch from one task to another easily and view graphics in a nice way.
Text terminal: A monitor that has only the capability of displaying text stuff, no graphics or a very basic graphics display.
Session: Time between logging on and logging out of the system.
Part 02 Linux Kernel Module ProgrammingTushar B Kute
Presentation on "Linux Kernel Module Programming".
Presented at Army Institute of Technology, Pune for FDP on "Basics of Linux Kernel Programming". by Tushar B Kute (http://tusharkute.com).
This is the slide deck I presented at the first CommCon event in the UK: it goes through some of the possible strategies for scaling WebRTC applications, mostly if you're using Janus but not only.
Embedded Recipes 2018 - Finding sources of Latency In your system - Steven Ro...Anne Nicolas
Having just an RTOS is not enough for a real-time system. The hardware must be deterministic as well as the applications that run on the system. When you are missing deadlines, the first thing that must be done is to find what is the source of the latency that caused the issue. It could be the hardware, the operating system or the application, or even a combination of the above. This talk will discuss how to determine where the latency is using tools that come with the Linux Kernel, and will explain a few cases that caused issues.
Tutorial: Using GoBGP as an IXP connecting routerShu Sugimoto
- Show you how GoBGP can be used as a software router in conjunction with quagga
- (Tutorial) Walk through the setup of IXP connecting router using GoBGP
This lecture Introduces how Linux Handles Input and Output of its processes. It discusses the TTY/PTY devices and different types of terminals (Physical Terminal, Virtual Terminals, and Emulated Terminals)
Check the other Lectures and courses in
http://Linux4EnbeddedSystems.com
or Follow our Facebook Group at
- Facebook: @LinuxforEmbeddedSystems
Lecturer Profile:
- https://www.linkedin.com/in/ahmedelarabawy
Linux offers an extensive selection of programmable and configurable networking components from traditional bridges, encryption, to container optimized layer 2/3 devices, link aggregation, tunneling, several classification and filtering languages all the way up to full SDN components. This talk will provide an overview of many Linux networking components covering the Linux bridge, IPVLAN, MACVLAN, MACVTAP, Bonding/Team, OVS, classification & queueing, tunnel types, hidden routing tricks, IPSec, VTI, VRF and many others.
FUSE and beyond: bridging filesystems slides by Emmanuel Dreyfuseurobsdcon
Abstract
Everything started with the desire to have a distributed filesystem better than NFS, which would be elastic and replicated with no SPOF. glusterFS was among the filesystems that could do that, but it uses The FUSE interface to the kernel, which was not available on NetBSD.
We will therefore discuss FUSE implementation and its NetBSD counterpart which is called PUFFS. A first but isufficient bridging attmpt called reFUSE was done, but porting real filesystems required the more complete PERFUSE bridge, which we will present here.
In a third part, we will look at the various unexpected roadblocks that had to be handled during PERFUSE implementation, in order to get a fully functionnal glusterFS on NetBSD.
Speaker bio
Emmanuel Dreyfus works as an IT manager at ESPCI ParisTech in France. He has been contributing for 13 years to NetBSD, in areas such as binary compatibility, and FUSE implementation. More at http://hcpnet.free.fr/pubz/
ABB are a leading manufacturer of medium voltage (MV) fuses used as main or back up protection elements of systems and apparatus. Fuses (commonly recognized as High Voltage Fuses) are classified as current limiting and non-current limiting (expulsion).
ABB fuses are designed based on wide application experience coming from designing of electrical protection in medium voltage systems and coordination with ABB products where fuses are applicable (air and SF6 insulated switchgears with load break switches, distribution transformers and contactors).
ABB MV HV medium-high voltage fuses protect distribution transformers, motors, switchgear and capacitor banks against overload currents - ABB MV-HV fuses can operate as sole devices or can be combined with air/SF6 insulated switch disconnectors. T&D distribute ABB medium voltage fuses for safe protection of 3.3kV, 6.6kV, 7.2kV, 11kV, 12kV 15kV, 20kV, 22kV, 24kV, 33kV, 36kV and 42kV cable systems.
KubeFuse - A File-System for KubernetesBart Spaans
A presentation on KubeFuse: the file-system view for Kubernetes.
For the introductory blog post see: https://opencredo.com/introducing-kubefuse-file-system-kubernetes/
The Linux Kernel Implementation of Pipes and FIFOsDivye Kapoor
A walkthrough of the code structure used in the linux kernel to implement pipes and FIFOs.
This was presented to a Senior level class at the Indian Institute of Technology, Roorkee.
An Introduction to User Space Filesystem DevelopmentMatt Turner
Writing a filesystem can be very cool. Alas, writing a filesystem is also very hard. This is mainly because coding in the kernel is hard. Thankfully, most of the pain can be avoided by using a library like FUSE. Such libraries enable filesystems to be expressed as simple userspace programmes by taking care of all that tedious mucking about in kernel space.
This talk will look at the Why and How of such filesystem development, using FUSE on UNIX. The talk will be very practical, with code on the screen and maybe even written in front of your very eyes (if I'm feeling brave).
There will be a short recap of how the VFS works on UNIX and then we'll dive into writing a filesystem with FUSE.
I'll go over my experiences of developing such filesystems - architectural patterns, testing, performance, etc. There will also be a section on the behaviours and gotchas of the libraries involved.
Glusterfs session #18 intro to fuse and its trade offsPranith Karampuri
This session covers fuse and its trade offs. Details of the session include:
- various parts of fuse code in the glusterfs source
tree
- the story FUSE version macros tell
- the tale of FUSE and fuse (historical context,
terminology)
- to libfuse or not to libfuse?
- FUSE proto breakdown
- mount and INIT
Best Practices For Direct Admin Securitylisa Dsouza
In this post, you'll learn about DirectAdmin security best practices.
For more information about direct admin hosting, visit here:
https://www.hostingseekers.com/category/web-hosting/directadmin-hosting
Part 03 File System Implementation in LinuxTushar B Kute
Presentation on "Virtual File System Implementation in Linux".
Presented at Army Institute of Technology, Pune for FDP on "Basics of Linux Kernel Programming". by Tushar B Kute (http://tusharkute.com).
This is a short introduction to some basic concepts about device drivers on Linux, and does not get into the nuts and bolts of it; uses a serial driver as an example, and how does it fit within the TTY layer. Includes code walk-through.
Dima Krasner talks about FUSE, Filesystem in Userspace, its pros and cons, usage, tips and tricks, and more.
Dima is a senior developer at Sam Seamless Network.
GridMate - End to end testing is a critical piece to ensure quality and avoid...ThomasParaiso2
End to end testing is a critical piece to ensure quality and avoid regressions. In this session, we share our journey building an E2E testing pipeline for GridMate components (LWC and Aura) using Cypress, JSForce, FakerJS…
GraphSummit Singapore | The Future of Agility: Supercharging Digital Transfor...Neo4j
Leonard Jayamohan, Partner & Generative AI Lead, Deloitte
This keynote will reveal how Deloitte leverages Neo4j’s graph power for groundbreaking digital twin solutions, achieving a staggering 100x performance boost. Discover the essential role knowledge graphs play in successful generative AI implementations. Plus, get an exclusive look at an innovative Neo4j + Generative AI solution Deloitte is developing in-house.
Pushing the limits of ePRTC: 100ns holdover for 100 daysAdtran
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
Essentials of Automations: The Art of Triggers and Actions in FMESafe Software
In this second installment of our Essentials of Automations webinar series, we’ll explore the landscape of triggers and actions, guiding you through the nuances of authoring and adapting workspaces for seamless automations. Gain an understanding of the full spectrum of triggers and actions available in FME, empowering you to enhance your workspaces for efficient automation.
We’ll kick things off by showcasing the most commonly used event-based triggers, introducing you to various automation workflows like manual triggers, schedules, directory watchers, and more. Plus, see how these elements play out in real scenarios.
Whether you’re tweaking your current setup or building from the ground up, this session will arm you with the tools and insights needed to transform your FME usage into a powerhouse of productivity. Join us to discover effective strategies that simplify complex processes, enhancing your productivity and transforming your data management practices with FME. Let’s turn complexity into clarity and make your workspaces work wonders!
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
Generative AI Deep Dive: Advancing from Proof of Concept to ProductionAggregage
Join Maher Hanafi, VP of Engineering at Betterworks, in this new session where he'll share a practical framework to transform Gen AI prototypes into impactful products! He'll delve into the complexities of data collection and management, model selection and optimization, and ensuring security, scalability, and responsible use.
A tale of scale & speed: How the US Navy is enabling software delivery from l...sonjaschweigert1
Rapid and secure feature delivery is a goal across every application team and every branch of the DoD. The Navy’s DevSecOps platform, Party Barge, has achieved:
- Reduction in onboarding time from 5 weeks to 1 day
- Improved developer experience and productivity through actionable findings and reduction of false positives
- Maintenance of superior security standards and inherent policy enforcement with Authorization to Operate (ATO)
Development teams can ship efficiently and ensure applications are cyber ready for Navy Authorizing Officials (AOs). In this webinar, Sigma Defense and Anchore will give attendees a look behind the scenes and demo secure pipeline automation and security artifacts that speed up application ATO and time to production.
We will cover:
- How to remove silos in DevSecOps
- How to build efficient development pipeline roles and component templates
- How to deliver security artifacts that matter for ATO’s (SBOMs, vulnerability reports, and policy evidence)
- How to streamline operations with automated policy checks on container images
Observability Concepts EVERY Developer Should Know -- DeveloperWeek Europe.pdfPaige Cruz
Monitoring and observability aren’t traditionally found in software curriculums and many of us cobble this knowledge together from whatever vendor or ecosystem we were first introduced to and whatever is a part of your current company’s observability stack.
While the dev and ops silo continues to crumble….many organizations still relegate monitoring & observability as the purview of ops, infra and SRE teams. This is a mistake - achieving a highly observable system requires collaboration up and down the stack.
I, a former op, would like to extend an invitation to all application developers to join the observability party will share these foundational concepts to build on:
State of ICS and IoT Cyber Threat Landscape Report 2024 previewPrayukth K V
The IoT and OT threat landscape report has been prepared by the Threat Research Team at Sectrio using data from Sectrio, cyber threat intelligence farming facilities spread across over 85 cities around the world. In addition, Sectrio also runs AI-based advanced threat and payload engagement facilities that serve as sinks to attract and engage sophisticated threat actors, and newer malware including new variants and latent threats that are at an earlier stage of development.
The latest edition of the OT/ICS and IoT security Threat Landscape Report 2024 also covers:
State of global ICS asset and network exposure
Sectoral targets and attacks as well as the cost of ransom
Global APT activity, AI usage, actor and tactic profiles, and implications
Rise in volumes of AI-powered cyberattacks
Major cyber events in 2024
Malware and malicious payload trends
Cyberattack types and targets
Vulnerability exploit attempts on CVEs
Attacks on counties – USA
Expansion of bot farms – how, where, and why
In-depth analysis of the cyber threat landscape across North America, South America, Europe, APAC, and the Middle East
Why are attacks on smart factories rising?
Cyber risk predictions
Axis of attacks – Europe
Systemic attacks in the Middle East
Download the full report from here:
https://sectrio.com/resources/ot-threat-landscape-reports/sectrio-releases-ot-ics-and-iot-security-threat-landscape-report-2024/
Removing Uninteresting Bytes in Software FuzzingAftab Hussain
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
Alt. GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using ...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
SAP Sapphire 2024 - ASUG301 building better apps with SAP Fiori.pdfPeter Spielvogel
Building better applications for business users with SAP Fiori.
• What is SAP Fiori and why it matters to you
• How a better user experience drives measurable business benefits
• How to get started with SAP Fiori today
• How SAP Fiori elements accelerates application development
• How SAP Build Code includes SAP Fiori tools and other generative artificial intelligence capabilities
• How SAP Fiori paves the way for using AI in SAP apps
Transcript: Selling digital books in 2024: Insights from industry leaders - T...BookNet Canada
The publishing industry has been selling digital audiobooks and ebooks for over a decade and has found its groove. What’s changed? What has stayed the same? Where do we go from here? Join a group of leading sales peers from across the industry for a conversation about the lessons learned since the popularization of digital books, best practices, digital book supply chain management, and more.
Link to video recording: https://bnctechforum.ca/sessions/selling-digital-books-in-2024-insights-from-industry-leaders/
Presented by BookNet Canada on May 28, 2024, with support from the Department of Canadian Heritage.
Sudheer Mechineni, Head of Application Frameworks, Standard Chartered Bank
Discover how Standard Chartered Bank harnessed the power of Neo4j to transform complex data access challenges into a dynamic, scalable graph database solution. This keynote will cover their journey from initial adoption to deploying a fully automated, enterprise-grade causal cluster, highlighting key strategies for modelling organisational changes and ensuring robust disaster recovery. Learn how these innovations have not only enhanced Standard Chartered Bank’s data infrastructure but also positioned them as pioneers in the banking sector’s adoption of graph technology.
Dr. Sean Tan, Head of Data Science, Changi Airport Group
Discover how Changi Airport Group (CAG) leverages graph technologies and generative AI to revolutionize their search capabilities. This session delves into the unique search needs of CAG’s diverse passengers and customers, showcasing how graph data structures enhance the accuracy and relevance of AI-generated search results, mitigating the risk of “hallucinations” and improving the overall customer journey.
3. Introduction(1/2)
• FUSE is a loadable kernel module for Unix-like computer
operating systems that lets non-privileged users create
their own file systems without editing kernel code.
• This is achieved by running file system code in user
space while the FUSE module provides only a "bridge" to
the actual kernel interfaces.
• FUSE is particularly useful for writing virtual file systems.
Unlike traditional file systems that essentially save data to
and retrieve data from disk, virtual filesystems do not
actually store data themselves. They act as a view or
translation of an existing file system or storage device.
3
4. Introduction(2/2)
• The FUSE system was originally part of A Virtual
Filesystem (AVFS), but has since split off into its own
project on SourceForge.net.
• FUSE is available for Linux, FreeBSD, NetBSD,
OpenSolaris, and Mac OS X. It was officially merged into
the mainstream Linux kernel tree in kernel version 2.6.14.
4
5. Examples(1/2)
• ExpanDrive: A commercial filesystem implementing
SFTP/FTP/FTPS using FUSE.
• GlusterFS: Clustered Distributed Filesystem having
capability to scale up to several petabytes.
• SSHFS: Provides access to a remote filesystem
through SSH.
• GmailFS: Filesystem which stores data as mail in Gmail
• EncFS: Encrypted virtual filesystem
5
6. Examples(2/2)
• NTFS-3G和Captive NTFS: allowing access
to NTFS filesystem.
• WikipediaFS : View and edit Wikipedia articles as if they
were real files.
• Sun Microsystems’s Lustre cluster filesystem
• Sun Microsystems’s ZFS
• HDFS: FUSE bindings exist for the open source Hadoop
distributed filesystem.
6
7. FUSE Installation
• http://fuse.sourceforge.net/
• ./configure
• make
• make install
7
8. FUSE source code
• ./doc: contains FUSE-related documentation. Ex: how-fuse-
works
• ./include: contains the FUSE API headers, which you need
to create a file system. The only one you need now is fuse.h.
• ./lib: holds the source code to create the FUSE libraries that
you will be linking with your binaries to create a file system.
• ./util: has the source code for the FUSE utility library.
• ./example: contains samples for your reference.
8
13. User programs
calls
fuse_main()
(lib/helper.c)
fuse_mount()
(lib/mount.c)
fork fusermount()
fd,exit (util/fusermount)
fd
calls fuse_new()
(lib/fuse.c)
data structure
13
14. fuse_loop(),
calls fuse_loop_mt()
(lib/fuse.c,
lib/fuse_mt.c)
session_exit
n
Receive session
y
Process session
Uninstall fuse fs
14
15. The fuse library(1/5)
• When your user mode program calls fuse_main()
(lib/helper.c),fuse_main() parses the arguments passed to
your user mode program, then calls fuse_mount()
(lib/mount.c).
fuse_main() fuse_mount()
(lib/helper.c) (lib/mount.c)
15
16. The fuse library(2/5)
• fuse_mount() creates a UNIX domain socket pair, then
forks and execsfusermount (util/fusermount.c) passing it
one end of the socket in the FUSE_COMMFD_ENV
environment variable.
fuse_main() fuse_mount() fusermount()
(lib/helper.c) (lib/mount.c) (util/fusermount.c)
Create socketpair
fork
execfusermount /dev/fuse
16
17. The fuse library(3/5)
• fusermount (util/fusermount.c) makes sure that the fuse
module is loaded. fusermount then open /dev/fuse and
send the file handle over a UNIX domain socket back to
fuse_mount().
fuse_main() fuse_mount() fusermount()
(lib/helper.c) (lib/mount.c) (util/fusermount.c)
Fuse module is loaded
/dev/fuse Open /dev/fuse
Send filehandle
17
18. The fuse library(4/5)
• fuse_mount() returns the file handle for /dev/fuse to
fuse_main().
• fuse_main() calls fuse_new() (lib/fuse.c) which allocates
the struct fuse data structure that stores and maintains a
cached image of the filesystem data.
fuse_main() fuse_mount() fusermount()
(lib/helper.c) (lib/mount.c) (util/fusermount.c)
Return filehandle
fuse_new()
(lib/fuse.c)
/dev/fuse
18
19. The fuse library (5/5)
• Lastly, fuse_main() calls either fuse_loop() (lib/fuse.c) or
fuse_loop_mt() (lib/fuse_mt.c) which both start to read the file system
system calls from the /dev/fuse, call the user mode functions stored in
struct fuse_operations data structure before calling fuse_main().
• The results of those calls are then written back to the /dev/fuse file
where they can be forwarded back to the system calls.
fuse_loop(),
fuse_loop_mt() fuse_main() fuse_mount() fusermount()
(lib/fuse.c, (lib/helper.c) (lib/mount.c) (util/fusermount.c)
lib/fuse_mt.c) Return filehandle
fuse_new()
write read (lib/fuse.c)
/dev/fuse
19
20. Struct fuse_operations (1/9)
• int (*getattr) (const char *, struct stat *);
• Get file attributes.
• int (*readlink) (const char *, char *, size_t);
• Read the target of a symbolic link
• int (*mknod) (const char *, mode_t, dev_t);
• Create a file node.
• int (*mkdir) (const char *, mode_t);
• Create a directory. Note that the mode argument may not have the
type specification bits set, i.e. S_ISDIR(mode) can be false. To
obtain the correct directory type bits use mode | S_IFDIR
20
21. Struct fuse_operations (2/9)
• int (*unlink) (const char *);
• Remove a file
• int (*rmdir) (const char *);
• Remove a directory
• int (*symlink) (const char *, const char *);
• Create a symbolic link
• int (*rename) (const char *, const char *);
• Rename a file
• int (*link) (const char *, const char *);
• Create a hard link to a file
21
22. Struct fuse_operations (3/9)
• int (*chmod) (const char *, mode_t);
• Change the permission bits of a file
• int (*chown) (const char *, uid_t, gid_t);
• Change the owner and group of a file
• int (*truncate) (const char *, off_t);
• Change the size of a file
• int (*open) (const char *, struct fuse_file_info *);
• File open operation.
22
23. Struct fuse_operations (4/9)
• int (*read) (const char *, char *, size_t, off_t, struct
fuse_file_info *);
• Read data from an open file.
• int (*write) (const char *, const char *, size_t, off_t, struct
fuse_file_info *);
• Write data to an open file
• int (*statfs) (const char *, struct statvfs *);
• Get file system statistics
• int (*flush) (const char *, struct fuse_file_info *);
• Possibly flush cached data
23
24. Struct fuse_operations (5/9)
• int (*release) (const char *, struct fuse_file_info *);
• Release an open file. Release is called when there are no more
references to an open file: all file descriptors are closed and all
memory mappings are unmapped.
• int (*fsync) (const char *, int, struct fuse_file_info *);
• Synchronize file contents
• int (*setxattr) (const char *, const char *, const char *,
size_t, int);
• Set extended attributes
• int (*getxattr) (const char *, const char *, char *, size_t);
• Get extended attributes
24
25. Struct fuse_operations (6/9)
• int (*listxattr) (const char *, char *, size_t);
• List extended attributes
• int (*removexattr) (const char *, const char *);
• Remove extended attributes
• int (*opendir) (const char *, struct fuse_file_info *);
• Open directory. Unless the 'default_permissions' mount option is
given, this method should check if opendir is permitted for this
directory. Optionally opendir may also return an arbitrary filehandle
in the fuse_file_info structure, which will be passed to readdir,
closedir and fsyncdir.
25
27. Struct fuse_operations (8/9)
• void (*destroy) (void *);
• Clean up filesystem
• int (*access) (const char *, int);
• Check file access permissions
• int (*create) (const char *, mode_t, struct fuse_file_info *);
• Create and open a file. If the file does not exist, first create it with
the specified mode, and then open it.
• int (*ftruncate) (const char *, off_t, struct fuse_file_info *);
• Change the size of an open file
• int (*fgetattr) (const char *, struct stat *, struct
fuse_file_info *);
• Get attributes from an open file
27
28. Struct fuse_operations(9/9)
• int (*lock) (const char *, struct fuse_file_info *, int cmd,
struct flock *);
• Perform POSIX file locking operation
• int (*utimens) (const char *, const struct timespec tv[2]);
• Change the access and modification times of a file with
nanosecond resolution
• int (*bmap) (const char *, size_t blocksize, uint64_t *idx);
• Map block index within file to block index within device
28