Forem: Abby Nduta

Learning with AI: An experiment

Abby Nduta — Thu, 08 May 2025 08:26:04 +0000

Piping Challenge

I wanted to try how well AI can explain a long chain of piping commands.

The command:

I used ClaudeAI. I told it to explain the pipe command in Linux simply and then explain each command, explaining the input and output.

Prompt

I want to understand the pipe command in Linux. I want you to simply explain piping and then explain each of these commands and then walk me step by step on what the outputs and inputs will be for each step: Explain the pipeline: history | cut -c 8- | sort | uniq -c | sort -nr | head

I hadn’t understood what unique commands were, so the extra explanation made it clear.

I was still confused about the 8 characters in the cut -c 8- command so I asked Claude to explain this to me.

This didn’t make sense as in the initial explanation ClaudeAI had shown me only single digit history numbers in its output.

So I asked ClaudeAI about this.

I called it out.

I tested the history command on my terminal.

And then I showed my input to ClaudeAI.

Conclusion

AI might not be the greatest starting point when learning new or complex concepts. You are better off learning from other sources and then confirming your understanding with AI playing the role of a student you are teaching what you have learned.

It’s also important to test out something in your own environment. Like I tested the history command on my terminal.

How Customizable Agentic Systems Are Revolutionizing Business Operations

Abby Nduta — Wed, 07 May 2025 15:11:36 +0000

Artificial intelligence (AI) has become ubiquitous.

In the heart of Utah, OP Media Inc. has completed successful pilots, using AI to redefine information and process flows in healthcare and emergency services.

OP Media uses an AI, dubbed AiBL core (pronounced Abel), to achieve these incredible feats. AiBL works by taking advantage of human knowledge within your business or organization (subject matter experts, or SMEs).

AiBL core is a wonderful example of what has come to be known as agentic AI. Agentic AI systems “learn,” “grow,” and eventually make decisions with little human input.

Your staff and team members contain a wealth of knowledge that could easily get lost if not well documented and shared.

OP Media helps you create ops (not apps)—operational procedures that allow your team to document processes in real time and share them simply via URLs or QR codes.

You can deploy AiBL core in your organization, and it’ll learn both from existing knowledge and SMEs.

In this article, we explore agentic AI and compare it with its more popular counterpart, generative AI. We then look at how customizable agentic AIs, like AiBL, are transforming business processes.

We also showcase AiBL customers who are successfully using OP Media’s solutions. Ultimately, we delve into the competitive advantage of organizations using customized AI agents.

Agentic AI versus Generative AI

All the jargon around AI can be perplexing. As a business leader, all you need are solutions that can help you achieve your goals. You don’t need to be bogged down with all the geekspeak.

However, understanding different AI aspects can help you narrow down the solutions that are best suited for your business.

Generative AI

Generative AI (GenAI) is able to create text, data visualizations, and images based on “seeing” lots of similar data.

The technology that powers GenAI is known as large language models (LLMs). These models are able to analyze large volumes of data, usually from the internet, and identify patterns, which they then use to create new text and visualizations.

Some popular GenAI products built on LLMs include ChatGPT, Gemini, Claude, Grok, and Llama.

GenAI use cases

GenAI solves real problems across industries. Volkswagen, for example, has created a GenAI system that allows drivers in the United States to study vehicle owner’s manuals and ask questions to better understand their owners’ cars.

Another company creates “smarter” billboards. These billboards display localized ads that update in real time based on available data.

Agentic AI

Agentic AI, on the other hand, is able to make decisions on behalf of a human. It has agency, like the name suggests. That might sound scary, but it only means that the AI takes steps based on the data it analyzes and the patterns it identifies.

AI agents

Agentic AI takes advantage of AI agents. An AI agent is a specialized software system. For example, a customer service AI agent knows how to respond to customer questions because they have studied copious amounts of customer queries and responses.

AI agents are able to learn from contexts. For instance, they can learn from their interactions with human customer service representatives. They can learn how humans respond and incorporate that into their “knowledge repertoire.”

LLMs, agentic AI and GenAI

Agentic AI is similar to GenAI, as they are powered by the same technology, LLMs. However, a human must prompt Gen AI to determine its next course of action. Agentic AI is able to make a decision based on what it already knows.

For example, if an AI agent is unable to resolve a customer complaint, it can refer the customer to the appropriate person, summarize previous interactions, and add relevant documents, making it easier to pick up from where the agent left.

Even if generative AI is more popular when compared to agentic AI, the latter can be highly customizable, as it can learn even from humans. This capability makes it a splendid option for business solutions requiring some degree of autonomy.

Human on the loop

It’s important to note that you can have a human review the decisions made by Agentic AI (known as a “human on the loop”). This way, any mistakes made can be noted and used to further streamline your AI agent’s data.

When they become "stuck," AI agents could also turn to a human for "help." In this way, they can be considered junior employees who learn from seniors.

AI agents in tandem

Another intriguing aspect of agentic AI is that multiple AI agents can work in tandem, further streamlining the “decision-making process.”

Agentic AI is still in its early stages. There is still so much more it can accomplish in the near future.

How customizable agentic systems like AiBL are transforming operations

Afu is OP Media’s CEO and founder. He has had a career spanning three decades in operations.

Afu refers to the type of AI that AiBL provides as “authentic” intelligence.

Incorporating tribal knowledge

AiBL is able to learn from front-line staff members. This characteristic is the main difference between AiBL and other agentic AI systems.

AI systems do have “a human in the loop.” LLMs, for example, have human AI trainers to help them better phrase conversations.

While AiBL can learn from organizational or business data, it is also able to learn from human SMEs. As these experts document processes, AiBL can pick up the new changes.

Understanding principles rather than just steps

AiBL can even question why the change was made, said Afu in a recent interview with Doug Jardine, Corporate Media and Communications Manager at OP Media.

Think about a child who tries to understand by asking “why” until he/she understands.

Simplifying knowledge capture and sharing

OP Media customers interact with AiBL via the OP System, a dashboard that can help you create and document processes (tagged operating procedures, OPs) in your business or organization.

Creating a process (OP) is relatively straightforward. OP Media also offers customer training to help you get on board faster.

You can then share your documented process via URL or a QR code that is scannable even with a phone.

The team receives real-time notifications when you introduce changes to your OP.

Your processes and standard operating procedures don’t have to live on PDFs that are difficult to track, manage, and update.

The OP System is a Software as a Service (SaaS) product accessible via the internet as long as you have an internet connection. You don’t need any coding knowledge to create an OP.

It comes with features like access control, so you can choose who needs to be added to an OP. You can also manage user permissions to ensure that only the correct people edit the OP when needed.

The OP system logs all data, which is helpful in understanding how your team is interacting with OPs. You can spot where staff is struggling and further streamline onboarding.

Meeting diverse security and compliance requirements

You can deploy AiBL within your own business infrastructure as well, running it completely on-prem. This feature gives you full control of your data and helps you comply with regulations.

OP Media has partnered with VirnetX, giving you an extra layer of security. VirnetX is a strategic and leading security solutions provider helping you run your on-prem solutions with the utmost security.

OP Media’s goal is to help companies, businesses, and organizations streamline their processes. You know your business and its processes. OP Media just provides the tech you need.

Real-world applications featuring OP Media customer case studies

The possibilities presented by agentic AI may seem akin to science fiction. It might be difficult to imagine any real-world applications.

OP Media is leading the way in providing the technology and tools for some intriguing agentic AI use cases in healthcare, emergency services, and even national defense.

There have been pilots in three Utah hospitals, Davis County’s emergency department, and with the Department of the Air Force Digital Transformation Office (DTO) via the Catalyst Operator program in Ogden, Utah.

Milford Memorial Hospital, Utah

Milford Memorial Hospital, Utah, went through OP Media’s pilot process and is now an OP Media customer. OP Media helped them learn how to create OPs via weekly training.

Guy Dansie, the hospital administrator, says that the OP system has helped them document institutional knowledge from staff members that could easily be lost. With the OP system, someone else can easily find a documented process if the person who usually works on a specific task is absent.

“As you do it more, you start thinking about it, sometimes at night or sometimes when you are having a conversation with a coworker. You think, ‘my goodness!’ I need to have this process recorded somehow.

So we have this great fear of losing that knowledge, institutional knowledge.

So what the OP allows us to do is to maintain that legacy information and or if somebody comes along in an emergency or somebody's out or sick or whatever, then they can step in and open the OP and figure out how to do that job.”

Guy adds that they share knowledge, expertise, and personnel, giving an example of a seasoned nurse who created an OP for the hospital’s emergency preparedness program.

“We have to have an economy of scale with certain positions. So we do share knowledge, we share expertise, and we share personnel. So some of that, for example, our emergency management for the hospital.

We had a wonderful nurse, a very seasoned nurse who had an excellent understanding of how to develop the emergency preparedness program for the hospital in Beaver, Utah, and we were able to implement that using her OP.”

He concludes by highlighting that they discovered that there could even be more applications beyond their initial ideas. There is a learning curve, though, for the staff members to understand the OPs and use them effectively.

“I think we're only limited by our imagination. I think as we started, I realized there are more and more applications. There are more things that I didn't think of initially. The way to grow our OPs use is actually to have our staff understand what the OPs are. And that takes time. It takes an educational learning curve.”

Davis County Emergency Services

OP Media also took Ember Herrick through their pilot process. Ember leads Davis County’s emergency services in Northern Utah.

Davis County is now also an OP Media customer. Ember created an OP, which is essentially a toolkit for new emergency managers. The OP was also used to map evacuation zones for residents, and it is accessible via a QR code.

With the OP, new emergency managers can access all the information they need in one place, from a growing, up-to-date document.
Emergency plans can also be updated on the fly, allowing for a free flow of information between residents, emergency managers, and the county.

Ember is now spearheading the creation of live emergency plans for each city in Davis County. The information collected can also be useful beyond planning. It can serve as a foundation for emergency funding.

She says that she liked that the pilot was “free” and that she’s always on the lookout for new technology to improve emergency preparedness in Davis County.

“I am always looking for new technology to improve emergency preparedness in Davis County. Of course, I liked the sound of a ‘free’ pilot. I also liked the idea of being able to change a process while it's in progress because things are continually changing in a disaster.”

Ember also shares how using outdated documentation impacted reimbursement after a natural disaster and how difficult it was to update the documentation.

“For example, after the 2020 windstorm that impacted Davis County public works staff began removing fallen trees from county property. Staff was documenting damages using preliminary damage assessment forms from 2011 when the last windstorm hit.

Several weeks into the cleanup process FEMA notified us that we needed to use updated forms with some additional questions. It was a hassle to get the forms switched out to all staff and communicate to them why the change was happening, this led to incomplete documentation that impacted the amount of reimbursement the county was able to recover from FEMA.”

Ember added that, with OP media’s OPs, she could share a QR code in the wake of a disaster with a documented damage assessment process. She could also make updates and share them immediately with all necessary parties.

“I was intrigued by the idea that I could share a QR code with public works in the immediate aftermath of a disaster with a predetermined damage assessment process in place and required fields in a survey. If additional questions needed to be added to the survey during the recovery I could make the update in OP Media and as soon as I published the changes, all public works staff would immediately have the latest version on their phone.”

The Department of the Air Force (DAF)

In 2023, OP Media was one of the businesses selected to solve a DAF challenge, which involved streamlining certification processes.

The DAF collaborates with the Catalyst Accelerator in Ogden to provide opportunities for technology companies to showcase and potentially provide national defense solutions.

OP Media is currently working on a pilot with defense-based companies that resulted from this opportunity.

As you can see, the possibilities are endless. As long as there is a process, OP Media can come in to help streamline and optimize it. It doesn’t matter whether that’s construction, defense, or healthcare.

Best practices for leveraging knowledge from subject matter experts

Ember and Guy are excellent examples of internal subject matter experts (SMEs) within an organization. SMEs are invaluable as they have institutional knowledge gained over time working for the company. They are good at their jobs and understand what works best for the business or organization.

A crucial part of optimizing processes in an organization is having the right people. SMEs can come in with their expertise to help you create and optimize processes, which you can then document via an evolving OP.

How do you identify potential SMEs in your company? How do you approach them to help with the goal you intend to achieve?

Remember they already have other work priorities. Let’s find out how you can identify and work with SMEs in your business.

Define the goal you want to achieve

Defining what you want to achieve helps you find the right SMEs to work with. Your goal might be to document a process so that it’s easier for other people to follow, for example.

Once you have the goal, it’s time to find the right people to help you achieve it.

Identify potential SMEs

SMEs can be anyone in the organization, really. It could be people in management who have been with the company for a significant period. They could be people who have joined the company recently but have a lot of expertise in their field.

A positive indicator of potential SMEs is employees who have an interest in personal growth. They, for example, attend conferences, write in publications (their own or otherwise), post on social media channels, are members of professional communities related to the industry, lead communities, or even sit on boards.

Another great approach to finding SMEs is people who like to help others. They are the “go-to” person when other people in the team need help. They already have outstanding people skills and can explain things in a way that others can understand.

Build an SME database

Once you have identified your potential SMEs, build a small database with their details. It could be a simple document with their names and specializations. Take some time to learn more about them. For instance, you could inquire about their hobbies and interests outside of work.

The database should be a growing document that you can update easily.

Approach the SMEs

Start talking to them and “pitching” what you want to achieve. Stay open-minded, as they may not have time to take on more responsibilities.

Give them the option to contribute in ways they deem most fit. Some might end up only being involved in decision-making. Others might be able to do more “hands-on” work, like actually creating the processes or training other staff members on how to use the OP once created.

You also need to consider the formats that they prefer to work with. Some might prefer to create videos or podcasts, while others may prefer to write.

Get creating

Once you have a small number of people, you can start to create the processes and OPs. The beautiful thing about OPs is they are customizable, so you can change or update them as needed. Give people the flexibility to join you and drop off if required.

Onboarding

Once the OPs are ready, you can teach people how to use them. It doesn’t have to be a whole conference. It could be 30 minutes before or after work, depending on their availability.

The idea is to make the onboarding smooth, without causing major disruptions to day-to-day business activities.

Monitoring

Allow some time for individuals to engage with the OPs. Check the generated system data to see areas of struggle. Note any questions they may have.

Periodically improve the OP. Eventually, you’ll have clearly documented, up-to-date processes that anyone can access.

Remember, the OPs are shareable even as QR codes.

The competitive advantage of organizations that deploy customized AI agents versus those using generic AI tools

Specialized AI agents have the potential to grossly outperform generic AI tools.

For example, junior customer service representatives at a Fortune 500 software firm showed a 34% increase in the hourly customer query resolutions when working with an AI tool that monitors customer chats and suggests probable responses.

Generic AI tools like ChatGPT, Claude, and Grok can be further tailored to meet your business and organizational needs. You can train them using your company’s data, for example, giving them context.

AI agents, on the other hand, are highly customizable as well, learning from company data and even interactions with human subject matter experts.

In this section, we explore the advantages of using customized AI, be it GenAI or agentic.

Better data privacy, control, and compliance

Once you deploy an AI system within your business and train it using your company’s data, you start to have more control over your data’s privacy.

Some data regulations require that your data stay within the physical confines of your business. If you serve customers in Europe, you also need to adhere to the General Data Protection Regulation (GDPR) and other policies around Personally Identifiable Information (PII).

Bespoke AI solutions allow you to become and remain compliant.

Faster strategic decision-making

Agentic AI systems can communicate with other agentic systems within an AI framework, contributing to faster decision-making.

For example, an AI agent whose primary job is to communicate with customers and help them with their complaints can “ask” for a specific customer’s account details from another AI agent that focuses on customer creditworthiness. It can then take the next appropriate action, based on the received data.

Improved operational efficiency and productivity

Customized AI solutions can help you increase productivity and efficiency in your company. For example, OP Media’s AiBL could suggest updates after noticing a pattern.

AiBL may notice that staff members keep on searching for a specific thing. They might be checking their company’s system for Health Insurance Portability and Accountability Act (HIPAA) compliance, for instance.

AiBL can then suggest adding processes around HIPAA, as it is a popular or frequent search.

Specialized AI systems have much more organizational knowledge. They “work” within your company or business. They can therefore provide information that’s more tailored to your business and customers.

Final Thoughts

We have delved into the thrilling world of agentic AI. Both GenAI and agentic AI are built from the same foundational technology, LLMs. Agentic AI wins the tussle by virtue of being able to make decisions with little human input.

OP Media is in the vanguard of agentic AI in business operations. Emergency services are just the tip of what AiBL can do.

We hope that this article gives you various perspectives on why agentic AI might be the missing piece in your business operations. When you have made the decision, we hope you choose OP Media to walk with you in your process optimization journey.

How To Set Up a VM With VirtualBox

Abby Nduta — Sat, 29 Mar 2025 22:22:51 +0000

The first time I had to set up a VM, I was preparing for my first ever OpenStack Horizon contribution. After trying it a couple of times of trying and failing, I gave up and did a local installation.

I contributed fine, but OpenStack is quite heavy. I crashed my laptop and had to reinstall it. By the time I was done, I was a “local installation” expert” (check out some devstack debugging tips, btw)

I then decided to try and install it in a VM, and when I finally had it working it literally felt like I had a “small computer” inside my desktop.

Jokes aside, I genuinely think that installing a VM successfully should be somewhere on a techie’s hall of fame, or a huge step to "growing up in tech."

I hope this guide saves you some considerable time.

Prerequisites

You have installed VirtualBox and VirtualBox Extension Pack.
You have an Ubuntu ISO image downloaded (I used ubuntu-24.04.2-desktop-amd64.iso).

Create a new VM in VirtualBox

We are now ready to start creating our VM.

Open VirtualBox and click "New."

Name your VM.
Choose the folder for the VirtualBox directory location (which is where you installed VirtualBox).
Choose the previously downloaded Ubuntu desktop ISO image.
Select "Linux" as the type, “Ubuntu” as the subtype, and "Ubuntu (64-bit)" as the version.
Allocate at least 8GB of RAM (8192MB). I have 16 GB of RAM; this is me living dangerously.
Create a new virtual hard disk (VDI) with at least 40GB of space (preferably 60 GB+).

A note on unattended install

This part helps with automatic OS installations.

Add your username and password (leave the password as the default one as changing it causes errors)
Hostname (I used DevStack-VM)
Domain name (you can use the default)

A word on the "install in background" option

If you check the "install in background" box, you won’t be able to see the installation process, as it’ll be running in the background. I’ll not check it for now, so that if there are any issues, you can see them.

Another note: Guest additions

The “Guest additions” checkbox allows further configuration between your host and VM. We’ll leave it unchecked for now.

Hardware configurations

Base Memory: 8192 MB (8 GB)—perfect for DevStack requirements
Processors: 4 CPUs

Hard Disk Configurations

We’ll create a new virtual hard disk with a size of 25 GB.
File type: VDI

You can now click “finish” to create the VM.
Wait for a few minutes for the Ubuntu installation and setup and other configurations to complete.
You can power the VM off.

Successful installation

If everything works well, you should be greeted with a “normal” Ubuntu login.

Input your password, and voila!

Set up the host network

We need to shut down the VM again to create a host-only network.

To safely shut down the VM:

sudo shutdown -h now

Once the VM is shut down, we need to create a host-only network.
Open VirtualBox and go to File > Tools > Network Manager.

Click "Create."
The network name should be "vboxnet0."

Configure the network adapters

Select your VM and click on "Settings."
Go to the "Network" tab.

Under "Adapter 1," check "Enable Network Adapter."
Choose Attached to NAT (this gives your VM internet access).

Under "Adapter 2," check "Enable Network Adapter."
Choose Set to Host-Only Adapter.
Select the network you just created from the dropdown menu.
Click OK to save the settings.
Start your VM again.

Find the VM’s IP address on the host-only network

Run ip addr

This should show you your network interfaces and IP addresses. Check that you have IP addresses under enp0s3 and enp0s8.

You’ll need the host-only network interface IP (enp0s8), as you’ll add it to your local.conf file when setting up DevStack.

Configure a static IP

DevStack will use a static IP to give you access to the Horizon dashboard.

sudo ip addr add 192.168.56.x/24 dev enp0s8 
sudo ip link set enp0s8 up

After doing this, run ip addr again to verify that enp0s8 has an IP address.

Forging Forward

You are now one step closer to your DevStack installation. I will discuss this in a separate post. I hope this works for you and you have a smooth install time.

Happy VMing!

Resources

https://medium.com/@ollste/openstack-local-development-how-to-install-test-and-use-openstack-in-virtualbox-b60b667886c4

Creating a Patch on OpenStack: A Checklist

Abby Nduta — Wed, 29 Jan 2025 09:28:48 +0000

Creating a patch on OpenStack can be time-consuming. Often, you need to go back to documentation to make sure that you have not missed any steps.

The documentation is, of course, well written. However, I find that there are a few things to keep in mind so that you can create a patch successfully at the first attempt.

This article is more of a checklist for you when creating a patch.

Checklist

OpenStack uses Gerrit as its review system and tox as its virtual environment management and test command line tool.

Let's go through the steps that you need to take to create a patch successfully the very first time.

1. Get the latest upstream changes

git remote update
git checkout master
git pull --ff-only origin master

2. Create a topic branch

git checkout -b TOPIC-BRANCH

3. Make your code changes

PyCharm helps you catch linting errors, so I'd advise using it.

4. Run tests

You can run tests in your tox virtual environment. You can also just run the test check in the directory or files that you made changes to.

Running tests ensures that you can rectify basic issues, if any, even before reviewers get to your code, saving everyone's time.

#run test checks within a tox virtual environment
tox -e <python version> 

#run test checks within a particular directory
tox -e <python version> -- <directory_path>

#run test checks within a particular file
tox -e <python version> -- <file_path>

5. Fix any errors highlighted

When the tests are done, a summary is generated that shows whether they passed or failed.

The system also generates a file containing the test results. If there are any errors, you need to fix them.

OpenStack's extensive code base may contain warnings unrelated to the recent changes you made. Don't worry too much about warnings. If they are within the files you changed, you might want to fix them.

6. Check for any JavaScript linting and code style errors

If you have any JavaScript code, you can check for any linting or code style errors. You can check for linting errors within a tox virtual environment.

tox -e npm -- lint

7. Ensure you fix any errors highlighted.

8. Check for any Python code style errors

OpenStack has a lot of Python code. If you have made changes to JavaScript code, it is likely to interact with the Python code. You can check for style errors in a tox virtual environment.

tox -e pep8

If you have any errors, fix them before proceeding.

9. Craft a commit message

You need to craft your commit message before you push your changes to Gerrit.To do that, you can use a text editor like vim or nano to ensure you meet the required guidelines.

When you create your patch, it automatically generates the Change-Id. You don't need to create one.

10. Commit your changes

You need to commit your change before submitting it for a review.

git add <file>
git commit -m "<commit message>"

11. Submit your change for review

You are now finally ready to submit your change for review by a project maintainer.

git review

You should see a success message to show that your change was submitted successfully.

12. Wait for merging

If your code changes are correct, then they should be merged in no time. If there are any more changes, you should get feedback from the maintainers.

13. Updating a change

If you need to make any more changes, do so, and then repeat all these steps. This time, however, since you have already created a patch, you'll run a different command during your commit.

git commit -a --amend

Forging Forward

It takes a while to master these steps. Don't worry if you have to sit down and dedicate some time to focus on this.

With practice, it could become second nature. For now, I hope this guide provides a checklist you can use to make your patch-creating process on OpenStack more seamless.

PS: Feel free to subscribe to my newsletter on substack: https://techiewhowrites.substack.com/

Sources

https://docs.opendev.org/opendev/infra-manual/latest/developers.html#quick-reference

6 Lessons From Implementing a Feature on OpenStack Horizon

Abby Nduta — Mon, 18 Nov 2024 09:39:59 +0000

Implementing the deactivate/reactivate feature was probably the most daunting experience in my tech journey.

I started contributing to OpenStack as part of the Outreachy program. I knew from the outset that I would be implementing some features from scratch, and I was scared.

Like any new contributor, I spent the first few weeks of my OpenStack Horizon contribution fixing bugs and writing tests.

However, the moment arrived for me to plunge into the depths of the pool. Sink or swim.

This post is a reflection about the decisions I made, the steps I took, and the lessons I learned.

Preliminary work

When you choose a project to contribute to under the Outreachy program, you get to see the features you’ll be working on.

I wasn’t sure which one I was going to start with, so my mentor suggested starting with the deactivate/reactivate feature.

The feature allows a user to change an image's status from 'active' to 'deactivated'.

Deactivating an image restricts further instance builds based on it.

Finding resources

I prefer to narrow down things before I begin to work on them. My first step, therefore, was to find resources that talked about the feature I was going to implement.

And the fastest way to do that was to ask my mentor whether she could send me some resources to get started.

She graciously sent some to me.

Delving into resources

I spent some time reading through the resources. The deactivate/reactivate feature already existed in Glance (OpenStack’s images service).

All I needed to do was implement it in Horizon.

The Glance docs had even specified the endpoints to use.

Deciding on an approach

I had previously interacted with the Openstack Horizon dashboard when expanding the features displayed in an image drawer.

My initial approach involved incorporating the deactivate/reactivate feature into the "Edit Image" workflow.

This implies that I would include it as an option when a user wished to edit an image on the Horizon dashboard.

When you click the "Launch" dropdown on a specific image, one of the options is "Edit Image".

When you click "Edit Image," it opens a modal.

At first, I wanted to create a third tab after "Metadata," which would allow a user to deactivate an image.

I would then implement the deactivate/reactivate feature as a toggle button. At face value, all I needed was a controller and a view.

Lessons galore

Having previously worked with controllers and views, I expected it to be a walk in the park.

This is where the lessons truly began to rack up.

Lesson 1 : Understanding the project structure saves a lot of time

I followed the project structure, and since I wanted to include my feature in the edit workflow, it was obvious that I would add it as another "step."

I studied the other "steps," how the controllers are written, how the different modules interacted with each other, and ensured that I could trace where every variable was defined or imported from.

Eventually, I began to see the patterns, and what needed to be imported from other directories and modules.

Of interest was the static directory

https://github.com/openstack/horizon/tree/master/horizon/static

which defined various templates and how to use them in your code.

Lesson 2: The business logic may not always be obvious

After writing the front-end Angular code it was time to implement the back-end functionality, which meant making a call to the Glance API.

This was a bit of a hassle. The Glance docs recommended using "POST" instead of "PATCH" as the HTTP method, and both Glance and Horizon had different URL paths.

After spending lots of time on this, it was time for the ultimate blocker.

Lesson 3: Ask for help with blockers

I had implemented the feature fully and explored every possibility I could think of, but the frontend was not communicating with the backend.

I checked the payload on developer tools, and the update was happening on the frontend. Despite calling the API from the backend, no update occurred.

Eventually, my mentor was able to figure out the missing part of the puzzle. We needed to add some more code in a different Django directory for the view to process the POST request made to the "deactivate endpoint."

The feature was now ready to go. Time to merge? Well, not that fast.

Lesson 4: Becoming a good engineer means taking care of code structure, linting, and ensuring that your code passes tests

Before pushing your code via Gerrit, you need to run some tests. OpenStack uses tox as its standard testing tool.

Once your tests have passed, you also need to check for lint errors. Thankfully, tox will help you identify any lint errors before you push your code.

In the event that you push code with lint errors, Zuul will highlight them too, making sure that only properly formatted and error free code is merged.

A really cool thing I learned was that Horizon’s NPM tests use thresholds to estimate code’s security.

This means that if a particular threshold is passed, the code is flagged. In my case, since I had added more features (which translated to more functions and variables), I had upset the threshold. The short-term solution was to modify the threshold.

Ultimately, writing tests would solve the threshold problem.

I love the fact that OpenStack has all these processes in place—linting, tox for testing, and Zuul for CI/CD. It would be a total mess to try and debug after code has already been merged.

Lesson 5: Lesson 5: PyCharm is arguably better than VS Code for Linting

PyCharm has really great linting options and is arguably better at it than VS Code. That said, I understand that there are impressive VSCode extensions to help with linting.

Despite its steeper learning curve, I found PyCharm to be significantly superior.

Lesson 6: Be open to changing your approach

At a certain point, despite correcting all linting errors, the tests continued to fail. It was time to attempt a different approach.

Instead of including the deactivate/activate feature as part of the "Edit Workflow," we decided to implement it as a separate action.

This meant that you could choose it from the dropdown next to "Launch."

The second approach would also reduce redundancy. The initial approach created an additional call to the API.

The new approach also included changing the commit message to reflect what I was implementing.

Forging forward

The OpenStack Horizon project is huge and complex. There’s still a lot to learn.

I hope these lessons will help you keep some things in mind as you contribute to OpenStack.

On to the next adventure. Writing tests 🚀

Debugging DevStack

Abby Nduta — Sat, 28 Sep 2024 09:50:14 +0000

I first installed OpenStack via DevStack months ago. I honestly forgot how frustrating it can be.

I followed the official docs and an article from DigitalOcean.

I'll summarize the main steps so that we can focus on debugging. Note that you need a fresh Ubuntu install for DevStack to work.

Main steps

Install Linux
Add Stack User
Download DevStack
Create a local.conf file
Start the install
Access OpenStack on a web browser

Usually, these steps should work seamlessly.

However, with subsequent installs, things may not go as expected.

Debugging options

There are some things you could try first:

Doing a fresh Ubuntu install and then repeating the above mentioned main steps
Running a most recent stable branch of devstack, not master.
Running './unstack.sh' and then './clean.sh'
Cleaning your 'opt/stack' directory
Running './stack.sh' again using the stable branch of devstack

Checking your errors

At this point in time, you have tried all the recommended debugging options and are convinced that there is a devstack bug somewhere.

There are a few workarounds depending on the errors you get, as well as a few changes to the local.conf file.

My errors

As you can see, I was getting a 'devstack@etcd.service' error. Stack overflow gave me the first workaround. I added 'disable_service etcd3' to my local.conf file and run 'stack.sh' again.

This cleared the 'devstack@etcd.service' error but introduced a 'keystone did not start' error.

After spending hours and hours down rabbit holes, after a brainstorming session with a friend, we suspected that the IP address could be the problem.

I had set my HOST_IP as my computer's IP address. I was reinstalling DevStack using a different network and there was a possibility that it could be picking the wrong IP address.

Initially, I tried to include my ISP's router IP address, but it didn't help.

Home run

I eventually changed my HOST_IP to 127.0.0.1 and passed it to the SERVICE_HOST.

I also added enabled Horizon in my local.conf 'ENABLED_SERVICES+=,horizon'

I then rerun 'stack.sh' and everything worked!!!!

Final thoughts

Debugging DevStack can be challenging. What are the bugs you've encountered? Feel free to share in the comments.

Delving into Angular in OpenStack Horizon: Directives

Abby Nduta — Wed, 07 Aug 2024 07:11:53 +0000

I've been exploring Angular within the context of OpenStack Horizon. First, it's important to know that the Horizon project uses Angular1 (AngularJS) which is quite old and deprecated. It's an old code base.

Your best bet at learning Angular1 is docs or this very useful book written by Brad Green and Shyam Seshadri.

Lastly, the code base uses ES5. Keeping this in mind will come in handy as it may be difficult to find resources or learning material. Most resources will teach you up-to-date modern Angular (Angular 2 and all subsequent versions).

Terminologies

It's advisable to learn AngularJS before tinkering with Horizon. I'll define the main concepts you need to know, though this blog focuses on the HTML, where you find directives.

AngularJS is based on the MVC concept, Model-View-Controller.

This means that you separate your code into:

models - the data to use in your project
views - the HTML that the user/DOM interacts with
controllers - where you keep your code's logic

Views

Views in Horizon are HTML files. They are made up of HTML elements and directives.

Directives are some sort of tags that we use to make our views more dynamic. Both AngularJS and Horizon have built-in directives, though you can create custom ones too. We'll learn more about them in our example.

Horizon also uses UI Bootstrap directives, though we won't be encountering them in this article.

Models

Horizon models are a bit different, since we make API calls to the OpenStack service we want, for example, Glance for images, rather than from a database.

We, however, within the context of Angular use models to store properties, for example.

Controllers

We make the API calls to the OpenStack service in the controller, return the results, and show them via the view.

Modules

Modules come in when we want to work with dependencies.

Services

Services come in when we want to perform specific tasks.

I've tried to keep the jargon simple, but you can learn more about the concepts from the AngularJS docs

Directives in Horizon

Like we mentioned, directives are 'special tags' we add to our views to make them dynamic.

Both AngularJS and Horizon have their own directives. I'm going to be making changes to the Images table on the Horizon dashboard.

Specifically, to the additional information you see when you expand the chevron arrow (>).

To begin, let's look at how the view looks like. Here's the drawer.html file we'll be working with:

https://github.com/openstack/horizon/blob/master/openstack_dashboard/static/app/core/images/details/drawer.html

<div ng-controller="horizon.app.core.images.DrawerController as drawerCtrl">

  <hz-resource-property-list
    resource-type-name="OS::Glance::Image"
    item="item"
    property-groups="[
      ['name', 'id'],
      ['visibility', 'protected'],
      ['disk_format', 'size'],
      ['min_disk', 'min_ram']]">
  </hz-resource-property-list>

  <div class="row" ng-if="drawerCtrl.metadataDefs">
    <div class="col-sm-12">
      <metadata-display
        available="::drawerCtrl.metadataDefs"
        existing="item.properties || item">
      </metadata-display>
    </div>
  </div>
</div>

Right off the bat, you can see some 'strange' tags like ng-controller, hz-resource-property-list, and ng-if.

These are what we call 'directives'. The 'ng' prefix means that they are built-in Angular directives. The 'hz' directives means that they are Horizon directives.

ng-controller specifies the controller we are going to use in the view. This should be the DrawerController aliased as drawerCtrl, and defined in the specified file path.

hz-resource-property-list is used to display a set of properties, and shows them in key-value pairs. It uses property groups, which divides the properties into lists.

These groups will be displayed as columns. We use any number of columns.

The groups can have as many properties as you need them to have.

In our code, inside the hzResourcePropertyList (this is how we write directives, though we use lowercase with dashes in the view as in hz-resource-property-list) we have 'property-groups' which shows that we'll display name, id, visibility, protected, disk_format, size, min_disk, and min_ram.

  <hz-resource-property-list
    resource-type-name="OS::Glance::Image"
    item="item"
    property-groups="[
      ['name', 'id'],
      ['visibility', 'protected'],
      ['disk_format', 'size'],
      ['min_disk', 'min_ram']]">
  </hz-resource-property-list>

resource-type-name also has some strange syntax. Horizon uses something called HEAT type names to specify the name of the resource we're working with, Glance in this case.

<hz-resource-property-list
    resource-type-name="OS::Glance::Image"
    item="item"
    property-groups="[
      ['name', 'id'],
      ['visibility', 'protected'],
      ['disk_format', 'size'],
      ['min_disk', 'min_ram']]">
  </hz-resource-property-list>

item is the data object that contains the properties that we want to display.

ng-if is a built-in AngularJS directive that helps us show information conditionally, just like you would in an if-else statement.

Additional Files

To understand the code in the drawer.html file, you need to look at additional files.

For example, ng-controller points to a controller named "Drawer Controller". This is defined in

https://github.com/openstack/horizon/blob/master/openstack_dashboard/static/app/core/images/summary.controller.js

(function() {
  'use strict';

  /**
   * @ngdoc controller
   * @name horizon.app.core.images.DrawerController
   * @description
   * This is the controller for the images drawer (summary) view.
   * Its primary purpose is to provide the metadata definitions to
   * the template via the ctrl.metadataDefs member.
   */
  angular
    .module('horizon.app.core.images')
    .controller('horizon.app.core.images.DrawerController', controller);

  controller.$inject = [
    'horizon.app.core.openstack-service-api.glance',
    'horizon.app.core.images.resourceType'
  ];

  var metadataDefs;

  function controller(glance, imageResourceType) {
    var ctrl = this;

    ctrl.metadataDefs = metadataDefs;
    if (!ctrl.metadataDefs) {
      applyMetadataDefinitions();
    }

    function applyMetadataDefinitions() {
      glance.getNamespaces({resource_type: imageResourceType}, true)
        .then(function setMetadefs(data) {
          ctrl.metadataDefs = data.data.items;
        });
    }
  }

})();

I won't delve into this code much.

You might want to also look at the overview file.

https://github.com/openstack/horizon/blob/master/openstack_dashboard/static/app/core/images/details/overview.html

It displays all the possible properties we can get from Glance.

On the dashboard, you'll see all these properties when you click on the name of the image, in this case, 'ndutas_image'

You should see all the properties.

Of importance is that the properties are grouped into three. This is reflected in the overview.html code.

<div ng-controller="ImageOverviewController as ctrl">
  <div class="row">
    <div class="col-md-6 detail">
      <h3 translate>Image</h3>
      <hr>
      <hz-resource-property-list
        resource-type-name="OS::Glance::Image"
        cls="dl-horizontal"
        item="ctrl.image"
        property-groups="[[
          'id', 'name', 'type', 'status', 'size', 'min_disk', 'min_ram', 'disk_format',
          'container_format', 'created_at', 'updated_at']]">
      </hz-resource-property-list>
    </div>
    <div class="col-md-6 detail">
      <h3>{$ 'Security' | translate $}</h3>
      <hr>
      <dl class="dl-horizontal">
        <dt translate>Owner</dt>
        <dd>{$ ctrl.image.owner $}</dd>
        <dt translate>Filename</dt>
        <dd>{$ ctrl.image.properties.filename | noValue $}</dd>
        <dt translate>Visibility</dt>
        <dd>{$ ctrl.image | imageVisibility:ctrl.projectId $}</dd>
        <dt translate>Protected</dt>
        <dd>{$ ctrl.image.protected | yesno $}</dd>
        <dt translate>Checksum</dt>
        <dd>{$ ctrl.image.checksum | noValue $}</dd>
      </dl>
    </div>
  </div>
  <div class="row">
    <div class="col-md-6 detail">
      <h3 translate>Custom Properties</h3>
      <hr>
      <dl class="dl-horizontal">
        <div ng-repeat="prop in ctrl.image.properties">
          <dt data-toggle="tooltip" title="{$ prop.name $}">{$ ctrl.resourceType.label(prop.name) $}</dt>
          <dd>{$ prop.value $}</dd>
        </div>
      </dl>
    </div>
  </div>
</div>

This will become important when we start to make changes.

If you want to see where this properties are listed, go to

https://github.com/openstack/horizon/blob/master/openstack_dashboard/static/app/core/images/images.module.js

Check the imageProperties function.

  function imageProperties(imagesService, statuses) {
    return {
      id: gettext('ID'),
      checksum: gettext('Checksum'),
      members: gettext('Members'),
      min_disk: gettext('Min. Disk'),
      min_ram: gettext('Min. RAM'),
      name: gettext('Name'),
      owner: gettext('Owner'),
      tags: gettext('Tags'),
      'updated_at': {label: gettext('Updated At'), filters: ['mediumDate'] },
      virtual_size: gettext('Virtual Size'),
      visibility: gettext('Visibility'),
      description: gettext('Description'),
      architecture: gettext('Architecture'),
      kernel_id: gettext('Kernel ID'),
      ramdisk_id: gettext('Ramdisk ID'),
      'created_at': {label: gettext('Created At'), filters: ['mediumDate'] },
      container_format: { label: gettext('Container Format'), filters: ['uppercase'] },
      disk_format: { label: gettext('Disk Format'), filters: ['noValue', 'uppercase'] },
      is_public: { label: gettext('Is Public'), filters: ['yesno'] },
      type: { label: gettext('Type')},
      'protected': { label: gettext('Protected'), filters: ['yesno'] },
      size: { label: gettext('Size'), filters: ['bytes'] },
      status: { label: gettext('Status'), values: statuses }
    };
  }

Showing More Properties in the Images Drawer

I want to add more properties to the images drawer, specifically, checksum, os_hash_value and os_hash_algo.

Currently, these do not exist on the dashboard.

Checksum is listed under the main properties to be shown in images.module.js.

This means that we can display it under the hzResourcePropertyList directive in drawer.html.

To do this, we need to add it as a property group.

  <hz-resource-property-list
    resource-type-name="OS::Glance::Image"
    item="item"
    property-groups="[
      ['name', 'id'],
      ['visibility', 'protected'],
      ['disk_format', 'size'],
      ['min_disk', 'min_ram'],
      ['checksum']]">
  </hz-resource-property-list>

os_hash_value and os_hash_algo are however not listed. If we check overview.html, there's custom properties code.

  <div class="row">
    <div class="col-md-6 detail">
      <h3 translate>Custom Properties</h3>
      <hr>
      <dl class="dl-horizontal">
        <div ng-repeat="prop in ctrl.image.properties">
          <dt data-toggle="tooltip" title="{$ prop.name $}">{$ ctrl.resourceType.label(prop.name) $}</dt>
          <dd>{$ prop.value $}</dd>
        </div>
      </dl>
    </div>
  </div>

os_hash_value and os_hash_algo are probably custom properties. How do we display them in the drawer?

Given that custom properties are still shown when you click the name of the image, it means that they are returned when we make the API call from Glance.

Since we don't want to show all the custom properties, we can conditionally show just os_hash_algo and os_hash_value.

  <div class="row" >
    <div class="col-sm-12">
      <dl>
        <div ng-if="item.properties.os_hash_algo">
          <dt>os_hash_algo</dt>
          <dd>{$ item.properties.os_hash_algo $}</dd>
        </div>
        <div ng-if="item.properties.os_hash_value">
          <dt>os_hash_value</dt>
          <dd>{$ item.properties.os_hash_value $}</dd>
        </div>
      </dl>
    </div>
  </div>

Restart the server

tox -e runserver

Go to

localhost:8000

We now see the changes. Note that you may need to restart your computer if you can't see any changes.

Forging Forward

This is a very simple introduction to Angular in OpenStack Horizon. There's definitely lots more to learn!!! I hope this guides you to try out Angular within the OpenStack Horizon context.

Resources

https://superuser.openinfra.dev/articles/dive-deep-into-openstack-horizon/
https://docs.angularjs.org/guide
https://www.amazon.com/AngularJS-Brad-Green/dp/1449344852
https://www.w3schools.com/js/js_es5.asp
https://www.tutorialspoint.com/angularjs/angularjs_mvc_architecture.htm
https://github.com/openstack/horizon/

Exploring Unit Testing in OpenStack Horizon

Abby Nduta — Wed, 10 Jul 2024 06:54:30 +0000

Context: I was accepted into Outreachy a few weeks ago and I'm working on OpenStack Horizon.

I've been working with Cinder, which is Block Storage on OpenStack.

I've been spending my time learning how to write unit tests on the OpenStack Horizon project.

I hope to share my reflections and what I've learned about writing unit tests on OpenStack.

Why Start With Unit Tests?

Unit tests are a great way to understand how various parts of the code interact with each other, and it's a highly recommended approach by the OpenStack community.

The main idea around unit tests is testing the smallest "piece of code" possible, usually a function or method.

Writing Unit Tests on OpenStack Horizon

I would like to begin by sharing some pitfalls to avoid.

Polish up on your knowledge

I would suggest polishing up on your unit testing basics first before attempting to write any unit tests. I'll share resources later on.

A lot of Cinder tests use mocking and patching. Learn about that too.

Go through existing tests

You also need to check how the rest of the tests are written. This will give you a clue about what's expected.

Follow the inheritance trail

Cinder code is basically Django classes, which means lots of inheritance. Make sure to follow the inheritance trail, all the way to the parent class.

That said, an example is always great.

Prerequisites

You have a working version of Horizon either on your PC or virtual machine
You have the latest code from master
You have created some volumes on the Horizon dashboard

A Unit Testing Example

I have horizon installed locally. I have created some volumes on my Horizon dashboard.

I need to write a test to determine whether the "AttachedTo" column on the Volumes table displays a dash [-], if the volume is not attached to an instance.

The first thing I need to do is find the code that generates the column on the volumes table.

You'll find it under

https://github.com/openstack/horizon/blob/master/openstack_dashboard/dashboards/project/volumes/tables.py

The specific class is AttachmentColumn. This is a custom column class for displaying volume attachments. It handles potential edge cases like empty attachments or incomplete server information.

class AttachmentColumn(tables.WrappingColumn):
    """Customized column class.

    So it that does complex processing on the attachments
    for a volume instance.
    """

    instance_detail_url = "horizon:project:instances:detail"

    def get_raw_data(self, volume):
        request = self.table.request
        link = _('%(dev)s on %(instance)s')
        attachments = []
        # Filter out "empty" attachments which the client returns...
        for attachment in [att for att in volume.attachments if att]:
            # When a volume is attached it may return the server_id
            # without the server name...
            instance = get_attachment_name(request, attachment,
                                           self.instance_detail_url)
            vals = {"instance": instance,
                    "dev": html.escape(attachment.get("device", ""))}
            attachments.append(link % vals)
        if attachments:
            return safestring.mark_safe(", ".join(attachments))

The test essentially tests this code:

if attachments:
            return safestring.mark_safe(", ".join(attachments))

Collecting the ingredients we need for our test

Check your Python version (if older, install mock from PyPI).
In newer versions, Python 3.3+, unitttest.mock is part of the library by default.
Think about what you want to test for (testing for None, equality, existence, truthiness,or falsiness).
In our case, we are testing for None, since the dash [-] translates to None.
Think about the scope of what you want to test. Do you want to write a test for the entire class? Or just the method? I went with the latter.
That means that we need to create an instance of the AttachmentColumn class, which inherits from tables.WrappingColumn.
Let's explore this class more.
The tables code is on this file path:

https://github.com/openstack/horizon/tree/master/horizon/tables

Go to the imports in the __init__.py file and find WrappingColumn

from horizon.tables.base import WrappingColumn

The WrappingColumn is defined in base.py.

https://github.com/openstack/horizon/blob/master/horizon/tables/base.py

class WrappingColumn(Column):
    """A column that wraps its contents. Useful for data like UUIDs or names"""

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self.classes.append('word-break')

It inherits from Column, which is also defined in base.py.
In the __init__ method of Column, we see that the only required argument is "transform"

    def __init__(self, transform, verbose_name=None, sortable=True,
                 link=None, allowed_data_types=None, hidden=False, attrs=None,
                 status=False, status_choices=None, display_choices=None,
                 empty_value=None, filters=None, classes=None, summation=None,
                 auto=None, truncate=None, link_classes=None, wrap_list=False,
                 form_field=None, form_field_attributes=None,
                 update_action=None, link_attrs=None, policy_rules=None,
                 cell_attributes_getter=None, help_text=None):

The docstrings suggest that is can be a string or callable.

"""A class which represents a single column in a :class:`.DataTable`.

    .. attribute:: transform

        A string or callable. If ``transform`` is a string, it should be the
        name of the attribute on the underlying data class which
        should be displayed in this column. If it is a callable, it
        will be passed the current row's data at render-time and should
        return the contents of the cell. Required.

We now have the attribute to use when creating an instance of AttachmentColumn.

Mocking

To imitate the functionality of the AttachmentColumn class, we need to create some mocks.Think about mocks as "mimics".
We could mimic a table which is where the column we intend to test lives, for example.
Mocks also come in handy because Horizon makes API calls to services like Cinder to display volume information. We would need to "mimic" this API calls too.
To display a volume, for example, we would need to send a request to Cinder, asking for volume information.
We would also need to "mimic" a volume, in this case, with the attachments attribute being an empty list, since it has no attachments.

Writing the Test

We are going to use the aforementioned unittest.mock library which has a Mock() class to help us in "mimicking"

    def test_attachment_column(self):
        column = volume_tables.AttachmentColumn("attachments")
        column.table = mock.Mock()
        column.table.request = mock.Mock()
        volume = mock.Mock()
        volume.attachments = []
        result = column.get_raw_data(volume)
        self.assertIsNone(result, None)

We defined a method called "test_attachment_column"
We then created an instance of AttachmentColumn. Since the class is contained in the tables module, we prefixed that. If you check the imports, the tables module is imported as volume_tables.
We then created a mock of our table, request, and volume, with the attachments attribute being an empty list.
In our code, we use mock.Mock() because we did not explicitly import Mock.

from unittest import mock

We then called our method, get_raw_data from the AttachmentColumn, passing in our volume as an argument.
Eventually, we created an assertion, assertIsNone, to confirm that our volume has no attachments, and that translates to 'None', our [-]
Note that we need to call the method we test (get_raw_data in our case) and use assert to compare the result with what we expect to get.

Checking the correctness of your test

We use tox within the OpenStack ecosystem to run tests. You can run this command in horizon's root directory:

tox -e py3.10 --  openstack_dashboard/dashboards/project/volumes/tests.py -r test_attachment_column

If using a different python version, then your command should be

tox -e <python_version> --  openstack_dashboard/dashboards/project/volumes/tests.py -r test_attachment_column

Your test should pass.

openstack_dashboard/dashboards/project/volumes/tests.py::VolumeIndexViewTests::test_attachment_column PASSED

You can also edit code in AttachmentColumn and rerun the test command to confirm that the code works.

#if attachments:
 return safestring.mark_safe(", ".join(attachments))

The test should now fail.

openstack_dashboard/dashboards/project/volumes/tests.py::VolumeIndexViewTests::test_attachment_column FAILED

A word on mocks

We could have used Mock() interchangeably with MagicMock(), but the latter is more powerful, with more "bells and whistles" which could break your tests, or cause some to pass/fail due to default MagicMock behaviour.

Forging Forward

There's still a lot to explore regarding unit tests within the OpenStack Horizon project. Some tests use pytest, for example, and others use the patch() decorator.

I hope that this blog would go a long way in helping you get started with unit testing in Horizon.

Resources

OpenStack Horizon Week 1: Project Navigation and Task 1

Abby Nduta — Wed, 05 Jun 2024 10:57:47 +0000

You might know that I'll be contributing to OpenStack Horizon. If not, you can read all about it in my application journey.

In this post, I share my progress this far.

Week 1

Week 1 was a roller coaster for me. I spent some time refreshing my Python and Django knowledge, but honestly there was still a lot to learn.

I spent the first week going through some tutorials, as I had already done the project set up during the contribution phase.

The tutorials were okay, and I started to understand the project somewhat.

Truth be told, OpenStack is a mammoth.

Task 1

I had my first meeting and it was apparent that we would need Angular to work with Glance, as there had been a transition. I have never written any Angular in my life, so that was quite a punch in the stomach.

So what next?

My mentors advised to start with Python/Django, so now the focus moved to Cinder(the initial plan was to work with Glance).

So, we set up the first task. And I realized that I had not even come across Cinder code even after spending some time going through the code.

My mentors were kind enough to go point me in the right direction.

The first task was fixing a really small bug.

Blockers

I was excited that my mentors wanted me to start small. My mentor had fixed the bug in like five minutes. I was like, okay, maybe it'll take me an hour tops.

When I actually sat down to write the code, I was quite lost. It took me quite a while to find the right files.

I then spent hours going through volumes code. I went through the classes, trying to understand what each was doing, and noting the ones responsible for the bug I was going to fix.

Murky waters

Somewhere along the way, I realized that the volumes code was not 100% mapped to Django file structure.

I couldn't find the templates responsible for that particular code. And after many hours I was in very muddy waters. I couldn't just figure out the connection between some files.

I went to bed without any sense of accomplishment.

Asking for help

I however was honest about not making some connections, and my mentor sent more resources my way.

Out of the Woods

It helps to work on code when my mind is settled. So I read through my mentors resources. One of them was a tutorial I already gone through.

I stepped back and tried to apply my experience getting lost with the resources. I was also able to narrow down to the specific code where the bug was.

Submitting my review

It took me a while to remember the steps I needed to take. I had copied and pasted a doc with some steps, but I couldn't trace its source.

I finally found it, and decided to write down the submitting a review steps for my future self, and hopefully, for someone else.

Forging onward

For now, there's still a long way to go, and I hope for many good days, without getting too lost in the woods.

Speaking OpenStack if you are coming from AWS

I've found it helpful to think about OpenStack in terms of AWS, since that's what I understand a little better. So here is "AWS-translated OpenStack"

There's much more, of course, these are just some main concepts.

Cover Image credits: https://bit.ly/4aNF3zB

My Outreachy Application Journey

Abby Nduta — Wed, 15 May 2024 11:32:27 +0000

I first learned about paid internships like Outreachy via Twitter. If you ask me, I look at a program like Outreachy as an apprenticeship.

Anyway, it was past the deadline and I subscribed to the newsletter and made a promise to myself to apply during the next cohort. This was 2023.

I didn't get in, but I was not discouraged. I'd apply again.

In this post, I'll share the things I did differently the second time. Please note, I don't know if that's why I was chosen, that would ultimately be the organizers decision.

The second attempt

So, I sat back and decided to try a different approach.

I started way early...

I knew from my previous application that there would be lots of writing to answer the essay questions. Since the questions are the same, I copied them on a Google Doc and wrote my answers even before the application date was announced.

I prioritized the application

I spent 30 minutes to an hour everyday for two weeks writing my answers since I was working a full-time job.

This meant that my answers were ready to go.

I read about other people's experiences

I spent some time reading through other people's experiences just to have some perspectives about application and choosing projects.

I reached out to previous interns

I had met someone who had done Outreachy before, so I asked for her input. This came in handy during the contribution phase.

I chose a project that was in line with my skills and that was interesting too

When the applications were opened, I spent three days going through the projects and narrowed down to three. Remember I had a full-time job, so I didn't have too much time.

I eventually settled on one project, as I wanted to focus in case I was chosen.

I sent my application in early

Since I already had my answers ready, I was done with the application early enough, even when there were many days left on to the deadline.

I sent my application, prayed, and waited

I sent the initial application, prayed and waited. I also kept taking notes about my next application, especially from Joan, who had participated before.

Contributing

Time flew by. I eventually got the acceptance email.

I started going through the project's docs, project files, issues and bugs

I spent the first two or three days going through the project's docs and codebase.

It was a bit overwhelming, but it gave me an idea of what the project was about.

Having AWS knowledge came in handy as I could translate the knowledge from AWS to OpenStack concepts.

I reached out to the project mentor

I reached out to the project mentor. I told her that I had been accepted to contribute to OpenStack, and shared the progress I had made.

I then asked her for guidance on how I could go about contributing. I was looking to make a very simple contribution as I didn't have too much time, again, I was working full-time.

This helped me narrow my focus, as I could concentrate on what was important without being overwhelmed.

I started contributing

Tatiana was very helpful in providing the resources I needed. I updated her on my progress every few days, including when I was stuck, and any workarounds I came up with.

The contributing phase was about three hours every day, so I would wake up really early so that I could have at least three hours before work.

I kept my mentor updated

As aforementioned, I kept my mentor updated on my progress. I also incorporated any feedback she gave.

Final Application

It was such a joy when my contribution got merged. It was my first ever merged open source contribution.

I had tried before, but my contribution was not merged.

Finishing up

I finished up my final application, after a go ahead from my mentor.

I then submitted, prayed and waited

I submitted my final application two days before the deadline. I then submitted, prayed and waited.

Acceptance

I was so anxious as I waited for the results. I refreshed my email like every five minutes.

But finally, I got the acceptance email. I was literally in the clouds with joy.

I did my victory dance too...and thanked God for his mercies...

Image source: https://www.furaffinity.net/view/49164924/

I signed the contract very fast...and called my friends to tell share the good news.

I also reached put to my mentor Tatiana again and thanked her for her support.

I also told her what I had in mind as prep work, as the contribution phase began later in the month.

Prep work

Tatiana guided me on the next steps, and the resources to look at.

I'm currently knee deep polishing up any dust off my Python/Django knowledge.

The future

I'm going to do my best to understand the project and deliver.

I'm also taking all the help I can get from my mentor, the OpenStack community, and the larger tech community.

I hope to staying humble, teachable, and have lots of fun!!!

And as you can imagine, I'll be praying lots too :)

Let me know if you have any questions.

The WWCode Days of Code Challenge

Abby Nduta — Mon, 08 Jan 2024 06:33:10 +0000

Staying consistent might not be easy at the start. Here's a challenge by #WomenWhoCodeAccra to help you stay on track.

✨ Join Women Who Code and our community of coders to level up your skills during our online Days of Code Challenge! Learn at your own pace with our fun, supportive community. Sign up starting today to begin the challenge on Monday, January 8th. ✨

The WWCode Days of Code Challenge is hosted by the WWCode Technical Track communities and is an ongoing, self-directed and self-paced learning experience that will allow you to start the New Year with a commitment to level up your skills!

Finding time to work on your skills or projects — or going at it alone — can be challenging. The WWCode Days of Code Challenge will give you the space and encouragement to improve your skills, finish projects, help other coders and learn from other technologists.

👩‍💻 Who this challenge is for:

Any technologist who wants to work on their coding skills in a supportive, interactive community.
All learning and coding levels.
All tech stacks.
💖 Why you should join:

Flexibility: Learn and work online at your own pace and level — and in your own tech stack.
Community: Meet, learn from, and mentor other coders who share your passion for tech.
New Year, New You: Start the New Year strong by building your network and knowledge to help you excel in your career in 2024!
📅 Join Today to Begin the Challenge Monday, January 8th

The challenge will happen online. Here’s how to join:

Register for the challenge on Hopin.
Attend the Opening Ceremony on January 8th at 11:00 AM EST, or access the recording afterwards, to learn all about how to participate in the program.

Start the challenge on Monday, January 8th (or your chosen start date)!
Code every day for your selected number of days — 7, 14, 30, 60, or 100.
Share your progress with the community at least once per week.
We look forward to learning with you!

Setting up PostgreSQL on a Django/Python project

Abby Nduta — Sun, 06 Aug 2023 08:59:04 +0000

Postgres is a popular relational database that you can use in your Python/Django project. Setting it up however, can be a little overwhelming.

Graciously, with Django models, you don’t have to write too many SQL queries to create your database, tables and even add data on your psql shell.

Here is your step by step summary to install and set up PostgreSQL on Ubuntu 22.04:

Check whether Postgres is installed

Open a terminal or command prompt.
Run the following command:

 psql --version

The version information will be displayed in the output.

Install Postgres

sudo apt update

sudo apt install postgresql postgresql-contrib

Start the PostgreSQL service

sudo systemctl start postgresql.service

Switch over to the postgres account

sudo -i -u postgres

Access the psql shell

psql

Create a superuser role with login privileges, and password

 CREATE ROLE <name_of_role> LOGIN PASSWORD <password_as_a string> BYPASSRLS;

Create database

CREATE DATABASE <database_name>;

Grant privileges on the database

GRANT ALL PRIVILEGES ON DATABASE <database_name> TO <created_superuser>;

Connect to the database (outside of psql and user postgres)

psql -U payments_admin -h localhost -p 5433 -d payments;

That's it, you are now ready to start going migrations to your database, and create tables based on your Django models.