33 |
36 | ) : (
37 |
45 |
32 |
34 | )}
35 |
36 | );
37 | };
38 |
39 | export default AvatarImage;
40 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/ChatList/components/ChatIcon.jsx:
--------------------------------------------------------------------------------
1 | const ChatIcon = () => (
2 |
30 | );
31 |
32 | export default ChatIcon;
33 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/ChatList/components/ChatListItem/index.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 | import "./style.css";
3 | import React, { useMemo } from "react";
4 | import moment from "moment";
5 | import { useEffect } from "react";
6 | import { getMessages } from "../../../../../../api";
7 | import AvatarImage from "../AvatarImage";
8 | import OnlineIndicator from "../../../OnlineIndicator";
9 | import useAppStateContext, {useAppState} from '../../../../../../state';
10 |
11 | /**
12 | * @param {{ active: boolean; room: import('../../../../../../state').Room; onClick: () => void; }} props
13 | */
14 | const ChatListItem = ({ room, active = false, onClick }) => {
15 | const { online, name, userId } = useChatListItemHandlers(room);
16 | return (
17 |
23 |
33 | );
34 | };
35 |
36 | const useChatListItemHandlers = (
37 | /** @type {import("../../../../../../state").Room} */ room
38 | ) => {
39 | const { id, name } = room;
40 | const [state] = useAppState();
41 | /** Here we want to associate the room with a user by its name (since it's unique). */
42 | const [isUser, online, userId] = useMemo(() => {
43 | try {
44 | let pseudoUserId = Math.abs(parseInt(id.split(":").reverse().pop()));
45 | const isUser = pseudoUserId > 0;
46 | const usersFiltered = Object.entries(state.users)
47 | .filter(([, user]) => user.Username === name)
48 | .map(([, user]) => user);
49 | let online = false;
50 | if (usersFiltered.length > 0) {
51 | online = usersFiltered[0].OnLine;
52 | pseudoUserId = +usersFiltered[0].id;
53 | }
54 | return [isUser, online, pseudoUserId];
55 | } catch (_) {
56 | return [false, false, "0"];
57 | }
58 | }, [id, name, state.users]);
59 |
60 | return {
61 | isUser,
62 | online,
63 | userId,
64 | name: room.name,
65 | };
66 | };
67 |
68 | export default ChatListItem;
69 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/ChatList/components/ChatListItem/style.css:
--------------------------------------------------------------------------------
1 | .chat-list-item {
2 | cursor: pointer;
3 | padding: 14px 16px;
4 | }
5 | .mdi-circle:before {
6 | content: "";
7 | }
8 |
9 | .mdi-set,
10 | .mdi:before {
11 | display: inline-block;
12 | font: normal normal normal 24px/1 Material Design Icons;
13 | font-size: inherit;
14 | text-rendering: auto;
15 | line-height: inherit;
16 | -webkit-font-smoothing: antialiased;
17 | -moz-osx-font-smoothing: grayscale;
18 | }
19 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/ChatList/components/Footer.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 |
3 | import React from "react";
4 | import { Power } from "react-bootstrap-icons";
5 | import OnlineIndicator from "../../OnlineIndicator";
6 | import AvatarImage from "./AvatarImage";
7 |
8 | const Footer = ({ user, onLogOut }) => (
9 |
24 |
26 |
27 |
29 |
30 |
32 | {name}
31 |
13 | {(
14 | <>
15 |
16 |
17 |
18 | )}
19 |
20 | );
21 |
22 | const LogoutButton = ({ onLogOut, col = 5, noinfo = false }) => (
23 | onLogOut()}
25 | style={{ cursor: "pointer" }}
26 | className={`col-${col} text-danger ${!noinfo ? "text-right" : ""}`}
27 | >
28 |
30 | );
31 |
32 | const UserInfo = ({ user = {}, col = 7, noinfo = false }) => (
33 |
38 |
51 | );
52 |
53 | export default Footer;
54 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/ChatList/index.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 | import React, { useMemo } from "react";
3 | import ChatListItem from "./components/ChatListItem";
4 | import Footer from "./components/Footer";
5 | import {useAppState} from '../../../../state';
6 | import {processChannelJoin, processChannelLeave} from '../../../../websockets/process';
7 |
8 | const ChatList = ({ rooms, user, currentRoom, onLogOut }) => {
9 | const [state, dispatch] = useAppState();
10 |
11 | const processedRooms = useMemo(() => {
12 | const roomsList = Object.values(rooms);
13 | const main = roomsList.filter((x) => x.id === "0");
14 | let other = roomsList.filter((x) => x.id !== "0");
15 | other = other.sort(
16 | (a, b) => +a.id.split(":").pop() - +b.id.split(":").pop()
17 | );
18 | return [...(main ? main : []), ...other];
19 | }, [rooms]);
20 |
21 | return (
22 | <>
23 |
39 |
41 | {!noinfo && (
42 |
43 |
49 | )}
50 | {user.username}
44 |
45 |
48 | Active
47 |
24 |
45 |
46 | );
47 | };
48 |
49 | export default ChatList;
50 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/MessageList/components/ClockIcon.jsx:
--------------------------------------------------------------------------------
1 | const ClockIcon = () => (
2 |
12 | );
13 |
14 | export default ClockIcon;
15 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/MessageList/components/InfoMessage.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 | const InfoMessage = ({ message }) => {
3 | return (
4 |
25 |
27 | Chats
26 |
28 |
43 |
44 |
29 | {processedRooms.map((room) => (
30 | {
33 | dispatch({type: "set current room", payload: room.id});
34 | // processChannelLeave();
35 | processChannelJoin(room.id);
36 | }}
37 | active={currentRoom === room.id}
38 | room={room}
39 | />
40 | ))}
41 |
42 | 8 | {message} 9 |
10 | ); 11 | }; 12 | 13 | export default InfoMessage; 14 | -------------------------------------------------------------------------------- /client/src/components/Chat/components/MessageList/components/MessagesLoading.jsx: -------------------------------------------------------------------------------- 1 | // @ts-check 2 | import React from "react"; 3 | 4 | const MessagesLoading = () => { 5 | return ( 6 |
7 |
11 | );
12 | };
13 |
14 | export default MessagesLoading;
15 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/MessageList/components/NoMessages.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 | import React from "react";
3 | import { CardText } from "react-bootstrap-icons";
4 |
5 | const NoMessages = () => {
6 | return (
7 |
8 |
9 |
10 |
8 |
11 | );
12 | };
13 |
14 | export default NoMessages;
15 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/MessageList/components/ReceiverMessage.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 | import moment from "moment";
3 | import React from "react";
4 | import ClockIcon from "./ClockIcon";
5 |
6 | const ReceiverMessage = ({
7 | username = "user",
8 | message = "Lorem ipsum dolor...",
9 | date,
10 | }) => (
11 | No messages
10 |
12 |
13 |
35 | );
36 | export default ReceiverMessage;
37 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/MessageList/components/SenderMessage.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 | import moment from "moment";
3 | import React from "react";
4 | import ClockIcon from "./ClockIcon";
5 | import OnlineIndicator from "../../OnlineIndicator";
6 |
7 | const SenderMessage = ({
8 | user,
9 | message = "Lorem ipsum dolor...",
10 | date,
11 | onUserClicked,
12 | }) => (
13 |
14 |
34 |
18 |
33 |
19 |
32 |
25 | {username}
26 |
27 | {message}
28 |
29 |
14 |
44 | );
45 |
46 | export default SenderMessage;
47 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/MessageList/index.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 | import React from "react";
3 | import {login, MESSAGES_TO_LOAD} from "../../../../api";
4 | import InfoMessage from "./components/InfoMessage";
5 | import MessagesLoading from "./components/MessagesLoading";
6 | import NoMessages from "./components/NoMessages";
7 | import ReceiverMessage from "./components/ReceiverMessage";
8 | import SenderMessage from "./components/SenderMessage";
9 |
10 | const MessageList = ({
11 | messageListElement,
12 | messages,
13 | room,
14 | onLoadMoreMessages,
15 | user = {},
16 | onUserClicked,
17 | }) => {
18 | return (
19 |
15 |
42 |
43 |
19 |
41 |
20 | {user && (
21 |
40 |
22 |
34 | )}
35 |
30 | {user.Username}
31 |
32 | {message}
36 |
37 |
23 | {messages === undefined ? (
24 |
88 | )};
89 | export default MessageList;
90 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/OnlineIndicator.jsx:
--------------------------------------------------------------------------------
1 | const OnlineIndicator = ({ online, hide = false, width = 8, height = 8 }) => {
2 | return (
3 |
9 | );
10 | };
11 |
12 | export default OnlineIndicator;
13 |
--------------------------------------------------------------------------------
/client/src/components/Chat/components/TypingArea.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 | const TypingArea = ({ message, setMessage, onSubmit }) => (
3 |
31 | {messages && messages.length !== 0 && (
32 | <>
33 | {room.offset && room.offset >= MESSAGES_TO_LOAD ? (
34 | onUserClicked(message.SenderUUID)}
66 | key={key}
67 | message={message.Message}
68 | date={message.CreatedAt}
69 | user={message.Sender}
70 | />
71 | );
72 | }
73 | return (
74 |
87 |
35 |
38 |
54 | ) : (
55 | <>
56 | )}
57 | {messages.map((message, x) => {
58 | const key = message.Message + message.CreatedAt + message.SenderUUID + x;
59 | if (message.SenderUUID === "info") {
60 | return
39 |
49 |
50 |
53 |
4 |
29 |
30 | );
31 |
32 | export default TypingArea;
33 |
--------------------------------------------------------------------------------
/client/src/components/Chat/index.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 | import React, {useCallback, useEffect, useRef, useState} from "react";
3 | import ChatList from "./components/ChatList";
4 | import MessageList from "./components/MessageList";
5 | import TypingArea from "./components/TypingArea";
6 | import useAppStateContext, {useAppState} from '../../state';
7 |
8 | /**
9 | * @param {{
10 | * onLogOut: () => void,
11 | * onMessageSend: (message: string, roomId: string) => void,
12 | * user: import("../../state").UserEntry
13 | * }} props
14 | */
15 | export default function Chat({ onLogOut, user, onMessageSend, users }) {
16 | const [{rooms, currentRoom}] = useAppState();
17 |
18 | const [room, setRoom] = useState({});
19 | const [message, setMessage] = useState("");
20 |
21 | const messageListElement = useRef(null);
22 |
23 | const scrollToBottom = useCallback(() => {
24 | if (messageListElement.current) {
25 | messageListElement.current.scrollTo({
26 | top: messageListElement.current.scrollHeight,
27 | });
28 | }
29 | }, []);
30 |
31 | useEffect(() => {
32 | scrollToBottom();
33 | }, [rooms[currentRoom].messages, scrollToBottom]);
34 |
35 | useEffect(() => {
36 | setRoom(rooms[currentRoom]);
37 | }, [currentRoom])
38 |
39 | return (
40 |
41 |
85 | );
86 | }
87 |
--------------------------------------------------------------------------------
/client/src/components/LoadingScreen.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 | import React from "react";
3 |
4 | export function LoadingScreen() {
5 | return (
6 |
42 |
84 |
43 |
50 | {/* Chat Box*/}
51 |
52 | {
72 | e.preventDefault();
73 | if (message) {
74 | onMessageSend(message.trim(), room.id);
75 | setMessage("");
76 |
77 | messageListElement.current.scrollTop =
78 | messageListElement.current.scrollHeight;
79 | }
80 | }}
81 | />
82 |
83 |
53 |
58 | 54 | {room ? room.name : "Room"} 55 | {" Room"} 56 |
57 |
7 |
11 | );
12 | }
13 |
--------------------------------------------------------------------------------
/client/src/components/Login/index.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 | import { Toast } from "react-bootstrap";
3 | import React, { useState, useRef } from "react";
4 | import Logo from "../Logo";
5 | import "./style.css";
6 | import { useEffect } from "react";
7 |
8 | const DEMO_USERS = ["Pablo", "Joe", "Mary", "Alex"];
9 |
10 | export default function Login({ onLogIn,setShowLogin }) {
11 | const [username, setUsername] = useState(
12 | () => DEMO_USERS[Math.floor(Math.random() * DEMO_USERS.length)]
13 | );
14 | const [password, setPassword] = useState("password123");
15 | const [error, setError] = useState(null);
16 |
17 | const onSubmit = async (event) => {
18 | event.preventDefault();
19 | onLogIn(username, password, setShowLogin);
20 | };
21 |
22 | return (
23 | <>
24 |
8 |
9 |
10 |
25 |
132 |
133 | );
134 | }
135 |
136 | const UsernameSelect = ({ username, setUsername, names = [""] }) => {
137 | const [open, setOpen] = useState(false);
138 | const [width, setWidth] = useState(0);
139 | const ref = useRef();
140 | /** @ts-ignore */
141 | const clientRectWidth = ref.current?.getBoundingClientRect().width;
142 | useEffect(() => {
143 | /** @ts-ignore */
144 | setWidth(clientRectWidth);
145 | }, [clientRectWidth]);
146 |
147 | /** Click away listener */
148 | useEffect(() => {
149 | if (open) {
150 | const listener = () => setOpen(false);
151 | document.addEventListener("click", listener);
152 | return () => document.removeEventListener("click", listener);
153 | }
154 | }, [open]);
155 |
156 | /** Make the current div focused */
157 | useEffect(() => {
158 | if (open) {
159 | /** @ts-ignore */
160 | ref.current?.focus();
161 | }
162 | }, [open]);
163 |
164 | return (
165 |
31 |
131 |
32 |
71 |
72 |
130 |
43 |
55 |
44 |
47 | Welcome Back !
45 |Sign in to continue
46 |
48 | 
53 |
54 |
53 |
59 |
70 |
67 |
69 | setOpen((o) => !o)}
170 | >
171 |
194 | );
195 | };
196 |
--------------------------------------------------------------------------------
/client/src/components/Login/style.css:
--------------------------------------------------------------------------------
1 | .login-form .username-select button {
2 | background-color: transparent !important;
3 | color: inherit;
4 | padding: 7.5px 12px !important;
5 | display: block !important;
6 | border: 1px solid rgb(206, 212, 218) !important;
7 | border-radius: 4px !important;
8 | width: 100% !important;
9 | text-align: left !important;
10 | }
11 |
12 | .login-form .username-select .btn-primary:not(:disabled):not(.disabled).active,
13 | .login-form .username-select .btn-primary:not(:disabled):not(.disabled):active,
14 | .show > .btn-primary.dropdown-toggle {
15 | color: inherit;
16 | }
17 |
18 | .login-form .username-select .dropdown-menu.show.dropdown-menu-right {
19 | transform: translate(0px, 38px) !important;
20 | }
21 |
22 | .username-select-dropdown {
23 | position: relative;
24 | display: flex !important;
25 | align-items: center;
26 | background-color: transparent !important;
27 | color: inherit;
28 | padding: 0 12px !important;
29 | border: 1px solid rgb(206, 212, 218) !important;
30 | border-radius: 4px !important;
31 | width: 100% !important;
32 | text-align: left !important;
33 | height: calc(1.5em + 0.94rem + 2px) !important;
34 |
35 | cursor: pointer;
36 | }
37 |
38 | .username-select-dropdown .username-select-block {
39 | background-color: var(--white);
40 | position: absolute;
41 | top: -1138px;
42 | left: 0;
43 | opacity: 0;
44 | transform: scale(0.5, 0.5);
45 | transform-origin: top left;
46 | transition: opacity 0.2s ease, transform 0.2s ease;
47 |
48 | border: 1px solid rgb(206, 212, 218) !important;
49 | border-radius: 4px !important;
50 |
51 | padding: 8px 0px;
52 | }
53 |
54 | .username-select-dropdown:focus {
55 | outline: none;
56 | border-color: #80bdff !important;
57 | box-shadow: 0 0 0 0.2rem rgba(0, 123, 255, 0.25);
58 | }
59 |
60 | .username-select-dropdown .username-select-block.open {
61 | top: 42px;
62 | transform: scale(1, 1);
63 | opacity: 1;
64 | }
65 |
66 | .username-select-row {
67 | display: flex;
68 | width: 100%;
69 | justify-content: space-between;
70 | align-items: center;
71 | }
72 |
73 | .username-select-dropdown .username-select-block .username-select-block-item {
74 | padding: 4px 24px;
75 | }
76 |
77 | .username-select-dropdown
78 | .username-select-block
79 | .username-select-block-item:hover {
80 | background-color: var(--light);
81 | }
82 |
--------------------------------------------------------------------------------
/client/src/components/Logo.jsx:
--------------------------------------------------------------------------------
1 | const Logo = ({ width = 64, height = 64 }) => {
2 | return (
3 |
45 | );
46 | };
47 |
48 | export default Logo;
49 |
--------------------------------------------------------------------------------
/client/src/components/Navbar.jsx:
--------------------------------------------------------------------------------
1 | // @ts-check
2 | import React, { useEffect, useState } from "react";
3 | import { getButtonLinks } from "../api";
4 |
5 | const Navbar = () => {
6 | /**
7 | * @type {[{
8 | * heroku?: string;
9 | * google_cloud?: string;
10 | * vercel?: string;
11 | * github?: string;
12 | * }, React.Dispatch
172 |
179 | {username}
173 |
174 |
177 |
178 |
183 | {names.map((name) => (
184 |
193 | setUsername(name)}
188 | >
189 | {name}
190 |
191 | ))}
192 | '+message+'
' + viewNodeSys.innerHTML;
50 | }
51 |
52 | export function viewErrorAdd(message) {
53 | if(viewNodeError == null){
54 | viewNodeError = node(nodeIdErrors);
55 | }
56 | }
57 |
58 |
59 |
60 |
61 | export function buildNodeMessage(message) {
62 | let divSender = "";
63 | if(typeof message.Sender != "undefined") {
64 | divSender = '';
65 | }
66 | let divRecipient = "";
67 | if(typeof message.Recipient != "undefined") {
68 | divRecipient = '';
69 | }
70 | if(divSender === "" && divRecipient === "") {
71 | return false;
72 | }
73 | let div = document.createElement("div");
74 | div.id = "message-" + message.UUID;
75 | div.innerHTML = divSender + divRecipient +
76 | '' +
77 | '' ;
78 |
79 | return div;
80 | }
81 |
82 | /*
83 | * @params message Object
84 | * */
85 | export function viewMessagesAdd(message) {
86 | if(viewNodeMessages == null){
87 | viewNodeMessages = node(nodeIdMessages);
88 | }
89 |
90 | const messageNode = buildNodeMessage(message);
91 |
92 | if(messageNode === false) {
93 | return;
94 | }
95 | const nodes = viewNodeMessages.childNodes;
96 | if(nodes > 0){
97 | viewNodeMessages.insertBefore(nodes[0], messageNode);
98 | } else {
99 | viewNodeMessages.append(messageNode);
100 | }
101 | }
102 |
--------------------------------------------------------------------------------
/config/config.go:
--------------------------------------------------------------------------------
1 | package config
2 |
3 | import (
4 | _ "github.com/joho/godotenv/autoload"
5 | "os"
6 | )
7 |
8 | const (
9 | envNameServerAddress = "SERVER_ADDRESS"
10 | envNameClientLocation = "CLIENT_LOCATION"
11 | envNameRedisAddress = "REDIS_ADDRESS"
12 | envNameRedisPassword = "REDIS_PASSWORD"
13 |
14 | defaultRedisAddress = "localhost:6379"
15 | defaultServerAddress = ":40080"
16 | defaultClientLocation = "/usr/local/share/dinamicka/public"
17 | )
18 |
19 | type Config struct {
20 | ServerAddress string
21 | ClientLocation string
22 | RedisAddress string
23 | RedisPassword string
24 | }
25 |
26 | func NewConfig() *Config {
27 |
28 | addr := os.Getenv(envNameServerAddress)
29 | if port := os.Getenv("PORT"); port != "" {
30 | addr = ":" + port
31 | }
32 |
33 | config := &Config{
34 | ServerAddress: addr,
35 | ClientLocation: os.Getenv(envNameClientLocation),
36 | RedisAddress: os.Getenv(envNameRedisAddress),
37 | RedisPassword: os.Getenv(envNameRedisPassword),
38 | }
39 | if config.ServerAddress == "" {
40 | config.ServerAddress = defaultServerAddress
41 | }
42 | if config.ClientLocation == "" {
43 | config.ClientLocation = defaultClientLocation
44 | }
45 | if config.RedisAddress == "" {
46 | config.RedisAddress = defaultRedisAddress
47 | }
48 |
49 | return config
50 | }
51 |
--------------------------------------------------------------------------------
/docker-compose.yaml:
--------------------------------------------------------------------------------
1 | version: '3.8'
2 | services:
3 | redis:
4 | image: redis:5
5 | container_name: chat-redis
6 | hostname: chat-redis
7 | restart: always
8 | networks:
9 | - chat-demo
10 | api:
11 | build:
12 | context: .
13 | env_file:
14 | - .env
15 | image: chat-api
16 | container_name: chat-api
17 | ports:
18 | - 5000:5000
19 | restart: always
20 | depends_on:
21 | - redis
22 | networks:
23 | - chat-demo
24 | networks:
25 | chat-demo:
26 | driver: bridge
27 |
28 |
--------------------------------------------------------------------------------
/docs/YTThumbnail.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redis-developer/basic-redis-chat-demo-go/ccdab229a04b0ad02a4d75b479b57081aea093b9/docs/YTThumbnail.png
--------------------------------------------------------------------------------
/docs/screenshot000.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redis-developer/basic-redis-chat-demo-go/ccdab229a04b0ad02a4d75b479b57081aea093b9/docs/screenshot000.png
--------------------------------------------------------------------------------
/docs/screenshot001.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redis-developer/basic-redis-chat-demo-go/ccdab229a04b0ad02a4d75b479b57081aea093b9/docs/screenshot001.png
--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/redis-developer/basic-redis-chat-demo-go
2 |
3 | go 1.15
4 |
5 | require (
6 | github.com/go-redis/redis v6.15.9+incompatible
7 | github.com/gobwas/httphead v0.1.0 // indirect
8 | github.com/gobwas/pool v0.2.1 // indirect
9 | github.com/gobwas/ws v1.0.4
10 | github.com/google/go-cmp v0.5.4 // indirect
11 | github.com/google/uuid v1.2.0
12 | github.com/joho/godotenv v1.3.0
13 | github.com/kr/pretty v0.1.0 // indirect
14 | github.com/onsi/ginkgo v1.15.0 // indirect
15 | github.com/onsi/gomega v1.10.5 // indirect
16 | golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 // indirect
17 | gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 // indirect
18 | )
19 |
--------------------------------------------------------------------------------
/go.sum:
--------------------------------------------------------------------------------
1 | github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
2 | github.com/fsnotify/fsnotify v1.4.9 h1:hsms1Qyu0jgnwNXIxa+/V/PDsU6CfLf6CNO8H7IWoS4=
3 | github.com/fsnotify/fsnotify v1.4.9/go.mod h1:znqG4EE+3YCdAaPaxE2ZRY/06pZUdp0tY4IgpuI1SZQ=
4 | github.com/go-redis/redis v6.15.9+incompatible h1:K0pv1D7EQUjfyoMql+r/jZqCLizCGKFlFgcHWWmHQjg=
5 | github.com/go-redis/redis v6.15.9+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA=
6 | github.com/gobwas/httphead v0.1.0 h1:exrUm0f4YX0L7EBwZHuCF4GDp8aJfVeBrlLQrs6NqWU=
7 | github.com/gobwas/httphead v0.1.0/go.mod h1:O/RXo79gxV8G+RqlR/otEwx4Q36zl9rqC5u12GKvMCM=
8 | github.com/gobwas/pool v0.2.1 h1:xfeeEhW7pwmX8nuLVlqbzVc7udMDrwetjEv+TZIz1og=
9 | github.com/gobwas/pool v0.2.1/go.mod h1:q8bcK0KcYlCgd9e7WYLm9LpyS+YeLd8JVDW6WezmKEw=
10 | github.com/gobwas/ws v1.0.4 h1:5eXU1CZhpQdq5kXbKb+sECH5Ia5KiO6CYzIzdlVx6Bs=
11 | github.com/gobwas/ws v1.0.4/go.mod h1:szmBTxLgaFppYjEmNtny/v3w89xOydFnnZMcgRRu/EM=
12 | github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
13 | github.com/golang/protobuf v1.4.0-rc.1/go.mod h1:ceaxUfeHdC40wWswd/P6IGgMaK3YpKi5j83Wpe3EHw8=
14 | github.com/golang/protobuf v1.4.0-rc.1.0.20200221234624-67d41d38c208/go.mod h1:xKAWHe0F5eneWXFV3EuXVDTCmh+JuBKY0li0aMyXATA=
15 | github.com/golang/protobuf v1.4.0-rc.2/go.mod h1:LlEzMj4AhA7rCAGe4KMBDvJI+AwstrUpVNzEA03Pprs=
16 | github.com/golang/protobuf v1.4.0-rc.4.0.20200313231945-b860323f09d0/go.mod h1:WU3c8KckQ9AFe+yFwt9sWVRKCVIyN9cPHBJSNnbL67w=
17 | github.com/golang/protobuf v1.4.0/go.mod h1:jodUvKwWbYaEsadDk5Fwe5c77LiNKVO9IDvqG2KuDX0=
18 | github.com/golang/protobuf v1.4.2 h1:+Z5KGCizgyZCbGh1KZqA0fcLLkwbsjIzS4aV2v7wJX0=
19 | github.com/golang/protobuf v1.4.2/go.mod h1:oDoupMAO8OvCJWAcko0GGGIgR6R6ocIYbsSw735rRwI=
20 | github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
21 | github.com/google/go-cmp v0.3.1/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
22 | github.com/google/go-cmp v0.4.0/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
23 | github.com/google/go-cmp v0.5.4 h1:L8R9j+yAqZuZjsqh/z+F1NCffTKKLShY6zXTItVIZ8M=
24 | github.com/google/go-cmp v0.5.4/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE=
25 | github.com/google/uuid v1.2.0 h1:qJYtXnJRWmpe7m/3XlyhrsLrEURqHRM2kxzoxXqyUDs=
26 | github.com/google/uuid v1.2.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
27 | github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
28 | github.com/joho/godotenv v1.3.0 h1:Zjp+RcGpHhGlrMbJzXTrZZPrWj+1vfm90La1wgB6Bhc=
29 | github.com/joho/godotenv v1.3.0/go.mod h1:7hK45KPybAkOC6peb+G5yklZfMxEjkZhHbwpqxOKXbg=
30 | github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
31 | github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
32 | github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
33 | github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
34 | github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
35 | github.com/nxadm/tail v1.4.4 h1:DQuhQpB1tVlglWS2hLQ5OV6B5r8aGxSrPc5Qo6uTN78=
36 | github.com/nxadm/tail v1.4.4/go.mod h1:kenIhsEOeOJmVchQTgglprH7qJGnHDVpk1VPCcaMI8A=
37 | github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
38 | github.com/onsi/ginkgo v1.12.1/go.mod h1:zj2OWP4+oCPe1qIXoGWkgMRwljMUYCdkwsT2108oapk=
39 | github.com/onsi/ginkgo v1.15.0 h1:1V1NfVQR87RtWAgp1lv9JZJ5Jap+XFGKPi00andXGi4=
40 | github.com/onsi/ginkgo v1.15.0/go.mod h1:hF8qUzuuC8DJGygJH3726JnCZX4MYbRB8yFfISqnKUg=
41 | github.com/onsi/gomega v1.7.1/go.mod h1:XdKZgCCFLUoM/7CFJVPcG8C1xQ1AJ0vpAezJrB7JYyY=
42 | github.com/onsi/gomega v1.10.1/go.mod h1:iN09h71vgCQne3DLsj+A5owkum+a2tYe+TOCB1ybHNo=
43 | github.com/onsi/gomega v1.10.5 h1:7n6FEkpFmfCoo2t+YYqXH0evK+a9ICQz0xcAy9dYcaQ=
44 | github.com/onsi/gomega v1.10.5/go.mod h1:gza4q3jKQJijlu05nKWRCW/GavJumGt8aNRxWg7mt48=
45 | github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
46 | golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
47 | golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
48 | golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
49 | golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
50 | golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
51 | golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
52 | golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
53 | golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
54 | golang.org/x/net v0.0.0-20200520004742-59133d7f0dd7/go.mod h1:qpuaurCH72eLCgpAm/N6yyVIVM9cpaDIP3A8BGJEC5A=
55 | golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
56 | golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb h1:eBmm0M9fYhWpKZLjQUUKka/LtIxf46G4fxeEz5KJr9U=
57 | golang.org/x/net v0.0.0-20201202161906-c7110b5ffcbb/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
58 | golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
59 | golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
60 | golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
61 | golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
62 | golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
63 | golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
64 | golang.org/x/sys v0.0.0-20190904154756-749cb33beabd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
65 | golang.org/x/sys v0.0.0-20191005200804-aed5e4c7ecf9/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
66 | golang.org/x/sys v0.0.0-20191120155948-bd437916bb0e/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
67 | golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
68 | golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
69 | golang.org/x/sys v0.0.0-20210112080510-489259a85091/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
70 | golang.org/x/sys v0.0.0-20210309074719-68d13333faf2 h1:46ULzRKLh1CwgRq2dC5SlBzEqqNCi8rreOZnNrbqcIY=
71 | golang.org/x/sys v0.0.0-20210309074719-68d13333faf2/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
72 | golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
73 | golang.org/x/text v0.3.3 h1:cokOdA+Jmi5PJGXLlLllQSgYigAEfHXJAERHVMaCc2k=
74 | golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
75 | golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
76 | golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
77 | golang.org/x/tools v0.0.0-20201224043029-2b0845dc783e/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
78 | golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
79 | golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
80 | golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
81 | golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
82 | golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
83 | google.golang.org/protobuf v0.0.0-20200109180630-ec00e32a8dfd/go.mod h1:DFci5gLYBciE7Vtevhsrf46CRTquxDuWsQurQQe4oz8=
84 | google.golang.org/protobuf v0.0.0-20200221191635-4d8936d0db64/go.mod h1:kwYJMbMJ01Woi6D6+Kah6886xMZcty6N08ah7+eCXa0=
85 | google.golang.org/protobuf v0.0.0-20200228230310-ab0ca4ff8a60/go.mod h1:cfTl7dwQJ+fmap5saPgwCLgHXTUD7jkjRqWcaiX5VyM=
86 | google.golang.org/protobuf v1.20.1-0.20200309200217-e05f789c0967/go.mod h1:A+miEFZTKqfCUM6K7xSMQL9OKL/b6hQv+e19PK+JZNE=
87 | google.golang.org/protobuf v1.21.0/go.mod h1:47Nbq4nVaFHyn7ilMalzfO3qCViNmqZ2kzikPIcrTAo=
88 | google.golang.org/protobuf v1.23.0 h1:4MY060fB1DLGMB/7MBTLnwQUY6+F09GEiz6SsrNqyzM=
89 | google.golang.org/protobuf v1.23.0/go.mod h1:EGpADcykh3NcUnDUJcl1+ZksZNG86OlYog2l/sGQquU=
90 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
91 | gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
92 | gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
93 | gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
94 | gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
95 | gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
96 | gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
97 | gopkg.in/yaml.v2 v2.2.4/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
98 | gopkg.in/yaml.v2 v2.3.0 h1:clyUAQHOM3G0M3f5vQj7LuJrETvjVot3Z5el9nffUtU=
99 | gopkg.in/yaml.v2 v2.3.0/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
100 |
--------------------------------------------------------------------------------
/golang-chat-redis.service:
--------------------------------------------------------------------------------
1 | [Unit]
2 | Description=Golang Chat Redis Service
3 | #After=
4 |
5 | [Service]
6 | User=chat-demo
7 | Group=chat-demo
8 | LimitAS=infinity
9 | LimitRSS=infinity
10 | LimitCORE=infinity
11 | LimitNOFILE=65536
12 | WorkingDirectory=/usr/local/share/chat-demo/
13 | ExecStart=/usr/local/share/chat-demo/bin
14 | Restart=always
15 | RestartSec=5s
16 | StandardOutput=journal
17 | StandardError=journal
18 |
19 | [Install]
20 | WantedBy=multi-user.target
21 |
--------------------------------------------------------------------------------
/heroku.yml:
--------------------------------------------------------------------------------
1 | build:
2 | docker:
3 | web: Dockerfile
--------------------------------------------------------------------------------
/images/app_preview_image.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/redis-developer/basic-redis-chat-demo-go/ccdab229a04b0ad02a4d75b479b57081aea093b9/images/app_preview_image.png
--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "github.com/redis-developer/basic-redis-chat-demo-go/config"
6 | "github.com/redis-developer/basic-redis-chat-demo-go/message"
7 | "github.com/redis-developer/basic-redis-chat-demo-go/rediscli"
8 | "github.com/redis-developer/basic-redis-chat-demo-go/websocket"
9 | "log"
10 | "net/http"
11 | )
12 |
13 | func main() {
14 |
15 | cnf := config.NewConfig()
16 |
17 | log.Println(fmt.Sprintf("%+v", cnf))
18 | redisCli := rediscli.NewRedis(cnf.RedisAddress, cnf.RedisPassword)
19 | messageController := message.NewController(redisCli)
20 | http.Handle("/ws", websocket.Handler(redisCli, messageController))
21 | http.HandleFunc("/links", func(writer http.ResponseWriter, request *http.Request) {
22 | _,_ = writer.Write([]byte(`{"github":"https://github.com/redis-developer/basic-redis-chat-demo-go"}`))
23 | })
24 | http.Handle("/", http.FileServer(http.Dir(cnf.ClientLocation)))
25 | log.Fatal(http.ListenAndServe(cnf.ServerAddress, nil))
26 | }
27 |
28 |
--------------------------------------------------------------------------------
/marketplace.json:
--------------------------------------------------------------------------------
1 | {
2 | "app_name": "Basic Redis chat app in Golang",
3 | "description": "Showcases how to implement chat app in Golang",
4 | "type": "App",
5 | "contributed_by": "Redis",
6 | "repo_url": "https://github.com/redis-developer/basic-redis-chat-demo-go",
7 | "preview_image_url": "https://raw.githubusercontent.com/redis-developer/basic-redis-chat-demo-go/master/images/app_preview_image.png",
8 | "download_url": "https://github.com/redis-developer/basic-redis-chat-demo-go/archive/main.zip",
9 | "hosted_url": "",
10 | "quick_deploy": "true",
11 | "deploy_buttons": [
12 | {
13 | "heroku": "https://heroku.com/deploy?template=https://github.com/redis-developer/basic-redis-chat-demo-go"
14 | },
15 | {
16 | "Google": "https://deploy.cloud.run/?git_repo=https://github.com/redis-developer/basic-redis-chat-demo-go.git"
17 | }
18 | ],
19 | "language": [
20 | "Go"
21 | ],
22 | "redis_commands": [
23 | "SET",
24 | "SETEX",
25 | "GET",
26 | "DEL",
27 | "RPUSH",
28 | "LINDEX",
29 | "LLEN",
30 | "LRANGE",
31 | "SUBSCRIBE",
32 | "PUBLISH"
33 | ],
34 | "redis_use_cases": [
35 | "Pub/Sub"
36 | ],
37 | "redis_features": [],
38 | "app_image_urls": [
39 | "https://github.com/redis-developer/basic-redis-chat-demo-go/raw/master/docs/screenshot001.png"
40 | ],
41 | "youtube_url": "https://www.youtube.com/watch?v=miK7xDkDXF0",
42 | "special_tags": [],
43 | "verticals": [],
44 | "markdown": "https://github.com/redis-developer/basic-redis-chat-demo-go/raw/master/README.md"
45 | }
--------------------------------------------------------------------------------
/message/controller.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | import "github.com/redis-developer/basic-redis-chat-demo-go/rediscli"
4 |
5 | type Controller struct {
6 | r *rediscli.Redis
7 | }
8 |
9 | func NewController(r *rediscli.Redis) *Controller {
10 | return &Controller{
11 | r: r,
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/message/error.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | import "errors"
4 |
5 | type IError interface {
6 | Error() (uint32, error)
7 | }
8 | type Error struct {
9 | code uint32
10 | err error
11 | }
12 |
13 | func (err Error) Error() (uint32, error) {
14 | return err.code, err.err
15 | }
16 |
17 | func newError(errCode uint32, err error) IError {
18 | return Error{code: errCode, err: err}
19 | }
20 |
21 | const (
22 | errCodeOK uint32 = iota
23 | errCodeJSUnmarshal
24 | errCodeWSRead
25 | errCodeWSWrite
26 | errCodeSignIn
27 | errCodeSignUp
28 | errCodeSignOut
29 | errCodeRedisChannelMessage
30 | errCodeRedisChannelUsers
31 | errCodeRedisGetSessionUUID
32 | errCodeRedisGetUserByUUID
33 | errCodeRedisChannelJoin
34 | errCodeUserSetOnline
35 | )
36 |
37 | var (
38 | errWSRead = errors.New("could not read websocket connection")
39 | errSignIn = errors.New("could not signIn")
40 | errUserSetOnline = errors.New("could not set user status as OnLine")
41 | )
42 |
--------------------------------------------------------------------------------
/message/message.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | import (
4 | "fmt"
5 | "github.com/gobwas/ws"
6 | "github.com/redis-developer/basic-redis-chat-demo-go/rediscli"
7 | "io"
8 | "log"
9 | "net"
10 | "sync"
11 | )
12 |
13 | type (
14 | DataType string
15 | )
16 |
17 | const (
18 | DataTypeSys DataType = "sys"
19 | DataTypeReady DataType = "ready"
20 | DataTypeError DataType = "error"
21 | DataTypeUsers DataType = "users"
22 | DataTypeSignIn DataType = "signIn"
23 | DataTypeSignUp DataType = "signUp"
24 | DataTypeSignOut DataType = "signOut"
25 | DataTypeAuthorized DataType = "authorized"
26 | DataTypeUnAuthorized DataType = "unauthorized"
27 | DataTypeChannelJoin DataType = "channelJoin"
28 | DataTypeChannelMessage DataType = "channelMessage"
29 | DataTypeChannelMessages DataType = "channelMessages"
30 | DataTypeChannelLeave DataType = "channelLeave"
31 | )
32 |
33 | type Message struct {
34 | recipientsSessionUUID []string
35 | SUUID string `json:"SUUID,omitempty"`
36 | Type DataType `json:"type"`
37 | UserUUID string `json:"userUUID,omitempty"`
38 | User *rediscli.User `json:"user,omitempty"`
39 | UserAccessKey string `json:"userAccessKey,omitempty"`
40 | Sys *DataSys `json:"sys,omitempty"`
41 | Ready *DataReady `json:"ready,omitempty"`
42 | Error *DataError `json:"error,omitempty"`
43 | Users *DataUsers `json:"users,omitempty"`
44 | SignIn *DataSignIn `json:"signIn,omitempty"`
45 | SignUp *DataSignUp `json:"signUp,omitempty"`
46 | SignOut *DataSignOut `json:"signOut,omitempty"`
47 | Authorized *DataAuthorized `json:"authorized,omitempty"`
48 | ChannelJoin *DataChannelJoin `json:"channelJoin,omitempty"`
49 | ChannelMessage *DataChannelMessage `json:"channelMessage,omitempty"`
50 | ChannelLeave *DataChannelLeave `json:"channelLeave,omitempty"`
51 | }
52 |
53 | type DataAuthorized struct {
54 | UserUUID string `json:"userUUID"`
55 | AccessKey string `json:"accessKey"`
56 | }
57 |
58 | type DataUnAuthorized struct {
59 | UserUUID string `json:"userUUID"`
60 | AccessKey string `json:"accessKey"`
61 | }
62 |
63 | type Channel struct {
64 | conn net.Conn
65 | userUUID string
66 | }
67 |
68 | var channelSessionsJoins = map[string]map[string]Channel{}
69 | var channelSessionsSync = &sync.RWMutex{}
70 |
71 | var sessionChannel = map[string]string{}
72 | var sessionChannelSync = &sync.RWMutex{}
73 |
74 | func channelSessionsAdd(conn net.Conn, channelUUID, sessionUUID, userUUID string) {
75 | channelSessionsSync.Lock()
76 | if _, ok := channelSessionsJoins[channelUUID]; !ok {
77 | channelSessionsJoins[channelUUID] = make(map[string]Channel, 0)
78 | }
79 | channelSessionsJoins[channelUUID][sessionUUID] = Channel{conn: conn, userUUID: userUUID}
80 | channelSessionsSync.Unlock()
81 |
82 | sessionChannelSync.Lock()
83 | sessionChannel[sessionUUID] = channelUUID
84 | sessionChannelSync.Unlock()
85 |
86 | }
87 |
88 | func channelSessionsRemove(sessionUUID string) {
89 | sessionChannelSync.RLock()
90 | channelUUID := sessionChannel[sessionUUID]
91 | sessionChannelSync.RUnlock()
92 | if channelUUID == "" {
93 | return
94 | }
95 | channelSessionsSync.Lock()
96 | if _, ok := channelSessionsJoins[channelUUID]; ok {
97 | delete(channelSessionsJoins[channelUUID], sessionUUID)
98 | }
99 | channelSessionsSync.Unlock()
100 | }
101 |
102 | type Write func(conn io.ReadWriter, op ws.OpCode, message *Message) error
103 |
104 | func channelSessionsSendMessage(skipUserUUID, channelUUID string, write Write, message *Message) {
105 |
106 | channelSessionsSync.RLock()
107 | defer channelSessionsSync.RUnlock()
108 | for _, data := range channelSessionsJoins[channelUUID] {
109 | if skipUserUUID != "" && skipUserUUID == data.userUUID {
110 | log.Println(">>>>>>>>>>>>SKIP",skipUserUUID, fmt.Sprintf("%+v", message))
111 | continue
112 | }
113 | log.Println(">>>>>>>>>>>>SEND",skipUserUUID, fmt.Sprintf("%+v", message))
114 | if err := write(data.conn, ws.OpText, message); err != nil {
115 | log.Println(err)
116 | }
117 | }
118 |
119 | }
120 |
--------------------------------------------------------------------------------
/message/message_channel_join.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | import (
4 | "github.com/gobwas/ws"
5 | "github.com/redis-developer/basic-redis-chat-demo-go/rediscli"
6 | "log"
7 | "net"
8 | )
9 |
10 | type DataChannelJoin struct {
11 | RecipientUUID string `json:"recipientUUID,omitempty"`
12 | Messages []*rediscli.Message `json:"messages,omitempty"`
13 | Users []*rediscli.User `json:"users,omitempty"`
14 | }
15 |
16 | func (p Controller) ChannelJoin(sessionUUID string,conn net.Conn, op ws.OpCode, write Write, message *Message) (*rediscli.ChannelPubSub, IError) {
17 |
18 | errI := p.ChannelLeave(sessionUUID, write, &Message{
19 | SUUID: message.SUUID,
20 | Type: DataTypeChannelLeave,
21 | UserUUID: message.UserUUID,
22 | ChannelLeave: &DataChannelLeave{
23 | RecipientUUID: message.ChannelJoin.RecipientUUID,
24 | },
25 | })
26 | if errI != nil {
27 | log.Println(errI)
28 | }
29 |
30 | channelSessionsRemove(sessionUUID)
31 | user,err := p.r.UserGet(message.UserUUID)
32 | if err != nil {
33 | return nil, newError(100, err)
34 | }
35 |
36 | channel, channelUUID, err := p.r.ChannelJoin(message.UserUUID, message.ChannelJoin.RecipientUUID)
37 | if err != nil {
38 | return nil, newError(101, err)
39 | }
40 |
41 | messagesLen, err := p.r.ChannelMessagesCount(channelUUID)
42 | if err != nil {
43 | return nil, newError(111,err)
44 | }
45 |
46 | var offset int64
47 | var limit int64 = 10
48 |
49 | if messagesLen > limit {
50 | offset = messagesLen - 10
51 | limit = -1
52 | }
53 |
54 | channelMessages, err := p.r.ChannelMessages(channelUUID, offset, limit)
55 | if err != nil {
56 | return nil, newError(102, err)
57 | }
58 |
59 | channelUsers, err := p.r.ChannelUsers(channelUUID)
60 | if err != nil {
61 | return nil, newError(103, err)
62 | }
63 |
64 | channelSessionsAdd(conn, channelUUID, sessionUUID, message.UserUUID)
65 |
66 | err = write(conn, op, &Message{
67 | Type: DataTypeChannelJoin,
68 | ChannelJoin: &DataChannelJoin{
69 | RecipientUUID: message.ChannelJoin.RecipientUUID,
70 | Messages: channelMessages,
71 | Users: channelUsers,
72 | },
73 | })
74 | if err != nil {
75 | return nil, newError(104, err)
76 | }
77 |
78 | channelSessionsSendMessage("", channelUUID, write, &Message{
79 | Type: DataTypeSys,
80 | SUUID: sessionUUID,
81 | UserUUID: message.UserUUID,
82 | User: user,
83 | Sys: &DataSys{
84 | Type: DataTypeChannelJoin,
85 | ChannelJoin: &DataChannelJoin{
86 | RecipientUUID: message.ChannelJoin.RecipientUUID,
87 | },
88 | },
89 | })
90 |
91 | return channel, nil
92 | }
93 |
--------------------------------------------------------------------------------
/message/message_channel_leave.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | type DataChannelLeave struct {
4 | SenderUUID string `json:"senderUUID"`
5 | RecipientUUID string `json:"recipientUUID"`
6 | }
7 |
8 | func (p Controller) ChannelLeave(sessionUUID string, writer Write, message *Message) IError {
9 |
10 | channelUUID, err := p.r.ChannelLeave(message.UserUUID, message.ChannelLeave.RecipientUUID)
11 | if err != nil {
12 | return newError(0, err)
13 | }
14 |
15 | channelSessionsSendMessage("", channelUUID, writer, message)
16 | channelSessionsRemove(sessionUUID)
17 |
18 | return nil
19 |
20 | }
21 |
--------------------------------------------------------------------------------
/message/message_channel_message.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | import (
4 | "github.com/gobwas/ws"
5 | "github.com/google/uuid"
6 | "github.com/redis-developer/basic-redis-chat-demo-go/rediscli"
7 | "net"
8 | "time"
9 | )
10 |
11 | type DataChannelMessage struct {
12 | UUID string `json:"UUID"`
13 | Sender *rediscli.User `json:"Sender,omitempty"`
14 | SenderUUID string `json:"SenderUUID"`
15 | Recipient *rediscli.User `json:"Recipient,omitempty"`
16 | RecipientUUID string `json:"RecipientUUID"`
17 | Message string `json:"Message"`
18 | CreatedAt time.Time `json:"CreatedAt"`
19 | }
20 |
21 | func (p Controller) ChannelMessage(sessionUUID string, conn net.Conn, op ws.OpCode, writer Write, message *Message) IError {
22 |
23 | channelMessage := &rediscli.Message{
24 | UUID: uuid.NewString(),
25 | SenderUUID: message.UserUUID,
26 | RecipientUUID: message.ChannelMessage.RecipientUUID,
27 | Message: message.ChannelMessage.Message,
28 | CreatedAt: time.Now(),
29 | }
30 |
31 | channelUUID, err := p.r.ChannelMessage(channelMessage)
32 | if err != nil {
33 | return nil
34 | }
35 |
36 | channelSessionsSendMessage(message.UserUUID, channelUUID, writer, message)
37 |
38 | return nil
39 | }
40 |
--------------------------------------------------------------------------------
/message/message_error.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | type DataError struct {
4 | Code uint32 `json:"code"`
5 | Error string `json:"error"`
6 | Payload interface{} `json:"payload"`
7 | }
8 |
9 | func (p Controller) Error(code uint32, err error, sessionUID string, payload interface{}) *Message {
10 | return &Message{
11 | recipientsSessionUUID: []string{sessionUID},
12 | Type: DataTypeError,
13 | Error: &DataError{
14 | Code: code,
15 | Error: err.Error(),
16 | Payload: payload,
17 | },
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/message/message_ready.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | type DataReady struct {
4 | SessionUUID string `json:"sessionUUID"`
5 | }
6 |
7 | func (p Controller) Ready(sessionUUID string) *Message {
8 | return &Message{
9 | Type: DataTypeReady,
10 | Ready: &DataReady{
11 | SessionUUID: sessionUUID,
12 | },
13 | }
14 | }
15 |
--------------------------------------------------------------------------------
/message/message_signin.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | import (
4 | "fmt"
5 | "github.com/gobwas/ws"
6 | "log"
7 | "net"
8 | "sync"
9 | )
10 |
11 | type DataSignIn struct {
12 | UUID string `json:"uuid"`
13 | Username string `json:"username"`
14 | Password string `json:"password,omitempty"`
15 | }
16 |
17 | var usersConn = map[string]net.Conn{}
18 | var usersConnSync = &sync.RWMutex{}
19 |
20 | func (p Controller) SignIn(sessionUUID string, conn net.Conn, op ws.OpCode, write Write, message *Message) IError {
21 |
22 | log.Println("SignIn", sessionUUID, fmt.Sprintf("%+v", message))
23 |
24 | user, err := p.r.UserAuthorize(message.SignIn.Username, message.SignIn.Password)
25 | if err != nil {
26 | log.Println("SignIn", err)
27 | return newError(errCodeSignIn, err)
28 | }
29 |
30 | err = write(conn, op, &Message{
31 | Type: DataTypeAuthorized,
32 | Authorized: &DataAuthorized{
33 | UserUUID: user.UUID,
34 | AccessKey: user.AccessKey,
35 | },
36 | })
37 | if err != nil {
38 | return newError(0, err)
39 | }
40 |
41 | err = p.r.UserSetOnline(user.UUID)
42 | if err != nil {
43 | log.Println(fmt.Errorf("%s:%w", errUserSetOnline, err), sessionUUID, message)
44 | }
45 |
46 | usersConnSync.Lock()
47 | usersConn[message.UserUUID] = conn
48 | for _, conn := range usersConn {
49 | err := write(conn, op, p.SysSignIn(user))
50 | if err != nil {
51 | log.Println(err)
52 | }
53 | }
54 | usersConnSync.Unlock()
55 |
56 | return nil
57 | }
58 |
--------------------------------------------------------------------------------
/message/message_signout.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | import (
4 | "github.com/gobwas/ws"
5 | "net"
6 | )
7 |
8 | type DataSignOut struct {
9 | UUID string `json:"uuid"`
10 | }
11 |
12 | func (p Controller) SignOut(sessionUUID string, conn net.Conn, op ws.OpCode, write Write, message *Message) IError {
13 | _, err := p.r.UserGet(message.UserUUID)
14 | if err != nil {
15 | return newError(errCodeSignOut, err)
16 | }
17 |
18 | p.r.UserSignOut(message.UserUUID)
19 |
20 | err = write(conn, op, &Message{
21 | Type: DataTypeSignOut,
22 | SignOut: &DataSignOut{
23 | UUID: message.SignOut.UUID,
24 | },
25 | })
26 | if err != nil {
27 | return newError(0, err)
28 | }
29 |
30 | return nil
31 | }
32 |
--------------------------------------------------------------------------------
/message/message_signup.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | import (
4 | "github.com/gobwas/ws"
5 | "net"
6 | )
7 |
8 | type DataSignUp struct {
9 | Username string `json:"username"`
10 | Password string `json:"password"`
11 | }
12 |
13 | func (p Controller) SignUp(sessionUUID string, conn net.Conn, op ws.OpCode, write Write, message *Message) IError {
14 | user, err := p.r.UserCreate(message.SignUp.Username, message.SignUp.Password)
15 | if err != nil {
16 | return newError(0, err)
17 | }
18 |
19 | err = write(conn, op, &Message{
20 | Type: DataTypeAuthorized,
21 | Authorized: &DataAuthorized{
22 | UserUUID: user.UUID,
23 | AccessKey: user.AccessKey,
24 | },
25 | })
26 | if err != nil {
27 | return newError(0, err)
28 | }
29 |
30 | return nil
31 |
32 | }
33 |
--------------------------------------------------------------------------------
/message/message_sys.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | import "github.com/redis-developer/basic-redis-chat-demo-go/rediscli"
4 |
5 | type DataSys struct {
6 | Type DataType `json:"type"`
7 | Message string `json:"message,omitempty"`
8 | SignIn *DataSignIn `json:"signIn,omitempty"`
9 | ChannelJoin *DataChannelJoin `json:"channelJoin,omitempty"`
10 | ChannelLeave *DataChannelLeave `json:"channelLeave,omitempty"`
11 | }
12 |
13 | func SysMessage(message string) *Message {
14 | return &Message{
15 | Type: DataTypeSys,
16 | Sys: &DataSys{
17 | Type: DataTypeSys,
18 | Message: message,
19 | },
20 | }
21 | }
22 |
23 | func (p Controller) SysSignIn(user *rediscli.User) *Message {
24 | return &Message{
25 | Type: DataTypeSys,
26 | Sys: &DataSys{
27 | Type: DataTypeSignIn,
28 | SignIn: &DataSignIn{
29 | UUID: user.UUID,
30 | Username: user.Username,
31 | },
32 | },
33 | }
34 | }
35 |
36 | func (p Controller) SysChannelJoin(user *rediscli.User, recipientsUUID []string) *Message {
37 | return &Message{
38 | recipientsSessionUUID: recipientsUUID,
39 | Type: DataTypeSys,
40 | Sys: &DataSys{
41 | Type: DataTypeSignIn,
42 | SignIn: &DataSignIn{
43 | UUID: user.UUID,
44 | Username: user.Username,
45 | },
46 | },
47 | }
48 | }
49 |
50 | func (p Controller) SysChannelLeave(user *rediscli.User, recipientsUUID []string) *Message {
51 | return &Message{
52 | recipientsSessionUUID: recipientsUUID,
53 | Type: DataTypeSys,
54 | Sys: &DataSys{
55 | Type: DataTypeChannelLeave,
56 | ChannelLeave: &DataChannelLeave{
57 | SenderUUID: user.UUID,
58 | },
59 | },
60 | }
61 | }
62 |
--------------------------------------------------------------------------------
/message/message_users.go:
--------------------------------------------------------------------------------
1 | package message
2 |
3 | import (
4 | "github.com/go-redis/redis"
5 | "github.com/gobwas/ws"
6 | "github.com/redis-developer/basic-redis-chat-demo-go/rediscli"
7 | "net"
8 | )
9 |
10 | type DataUsers struct {
11 | Total int `json:"total"`
12 | Received int `json:"received"`
13 | Users []*rediscli.User `json:"users"`
14 | }
15 |
16 | func (p *Controller) Users(sessionUUID string, conn net.Conn, op ws.OpCode, write Write) IError {
17 |
18 | values, err := p.r.UserAll()
19 | if err == redis.Nil {
20 | return nil
21 | }
22 | if err != nil {
23 | return newError(0, err)
24 | }
25 |
26 | users := make([]*rediscli.User, 0, len(values))
27 |
28 | for i := range values {
29 |
30 | user := &rediscli.User{
31 | UUID: values[i].UUID,
32 | Username: values[i].Username,
33 | OnLine: p.r.UserIsOnline(values[i].UUID),
34 | }
35 | users = append(users, user)
36 | }
37 |
38 | err = write(conn, op, &Message{
39 | Type: DataTypeUsers,
40 | Users: &DataUsers{
41 | Total: len(users),
42 | Received: len(users),
43 | Users: users,
44 | },
45 | })
46 | if err != nil {
47 | return newError(0, err)
48 | }
49 |
50 | return nil
51 | }
52 |
--------------------------------------------------------------------------------
/rediscli/channel.go:
--------------------------------------------------------------------------------
1 | package rediscli
2 |
3 | import (
4 | "bytes"
5 | "encoding/json"
6 | "errors"
7 | "fmt"
8 | "github.com/go-redis/redis"
9 | "github.com/google/uuid"
10 | "log"
11 | "strings"
12 | "time"
13 | )
14 |
15 | const (
16 | keyChannelUsers = "channelUsers"
17 | keyChannelMessages = "channelMessages"
18 | keyChannelSenderRecipient = "channelSenderRecipient"
19 | )
20 |
21 | type Message struct {
22 | UUID string `json:"UUID"`
23 | SenderUUID string `json:"SenderUUID"`
24 | Sender *User `json:"Sender,omitempty"`
25 | RecipientUUID string `json:"RecipientUUID"`
26 | Recipient *User `json:"Recipient,omitempty"`
27 | Message string `json:"Message"`
28 | CreatedAt time.Time `json:"CreatedAt"`
29 | }
30 |
31 | func (r *Redis) getKeyChannelUsers(channelUUID string) string {
32 | return fmt.Sprintf("%s.%s", keyChannelUsers, channelUUID)
33 | }
34 |
35 | func (r *Redis) getKeyChannelMessages(channelUUID string) string {
36 | return fmt.Sprintf("%s.%s", keyChannelMessages, channelUUID)
37 | }
38 |
39 | func (r *Redis) getKeyChannelSenderRecipient(senderUUID, recipientUUID string) string {
40 | if recipientUUID == "" {
41 | recipientUUID = "public"
42 | }
43 | return fmt.Sprintf("%s.%s.%s", keyChannelSenderRecipient, senderUUID, recipientUUID)
44 | }
45 |
46 | func (r *Redis) getChannelUUID(senderUUID, recipientUUID string) (string, error) {
47 | if senderUUID == "" {
48 | return "", errors.New("empty sender UUID")
49 | }
50 | if recipientUUID == "" {
51 | return "public", nil
52 | }
53 | keySenderRecipient := r.getKeyChannelSenderRecipient(senderUUID, recipientUUID)
54 | channelUUID, err := r.client.Get(keySenderRecipient).Result()
55 | if err == redis.Nil {
56 | keyRecipientSender := r.getKeyChannelSenderRecipient(recipientUUID, senderUUID)
57 | channelUUID, err = r.client.Get(keyRecipientSender).Result()
58 | if err == redis.Nil {
59 | channelUUID = uuid.NewString()
60 | if err := r.client.Set(keySenderRecipient, channelUUID, 0).Err(); err != nil {
61 | return "", err
62 | }
63 | if err := r.client.Set(keyRecipientSender, channelUUID, 0).Err(); err != nil {
64 | return "", err
65 | }
66 | return channelUUID, nil
67 | } else if err != nil {
68 | return "", err
69 | }
70 | return channelUUID, nil
71 | } else if err != nil {
72 | return "", err
73 | }
74 | return channelUUID, nil
75 | }
76 |
77 | func (r *Redis) channelJoin(channelUUID, senderUUID, recipientUUID string) error {
78 | key := r.getKeyChannelUsers(channelUUID)
79 | if err := r.client.HSet(key, senderUUID, time.Now().String()).Err(); err != nil {
80 | return err
81 | }
82 | if recipientUUID != "" {
83 | if err := r.client.HSet(key, recipientUUID, time.Now().String()).Err(); err != nil {
84 | return err
85 | }
86 | }
87 | return nil
88 | }
89 |
90 | func (r *Redis) addChannelPubSub(channelUUID string, pubSub *redis.PubSub) *ChannelPubSub {
91 | channelPubSub := &ChannelPubSub{
92 | close: make(chan struct{}, 1),
93 | closed: make(chan struct{}, 1),
94 | pubSub: pubSub,
95 | }
96 | r.channelsPubSubSync.Lock()
97 | if _, ok := r.channelsPubSub[channelUUID]; !ok {
98 | r.channelsPubSub[channelUUID] = channelPubSub
99 | }
100 | r.channelsPubSubSync.Unlock()
101 | return channelPubSub
102 | }
103 |
104 | func (r *Redis) getChannelPubSub(channelUUID string) *ChannelPubSub {
105 | r.channelsPubSubSync.RLock()
106 | pubSub, ok := r.channelsPubSub[channelUUID]
107 | r.channelsPubSubSync.RUnlock()
108 | if !ok {
109 | return nil
110 | }
111 | return pubSub
112 | }
113 |
114 | func (r *Redis) ChannelJoin(senderUUID, recipientUUID string) (*ChannelPubSub, string, error) {
115 |
116 | channelUUID, err := r.getChannelUUID(senderUUID, recipientUUID)
117 | if err != nil {
118 | return nil, "", err
119 | }
120 |
121 | err = r.channelJoin(channelUUID, senderUUID, recipientUUID)
122 | if err != nil {
123 | return nil, "", err
124 | }
125 | pubSub := r.client.Subscribe(channelUUID)
126 | channel := r.addChannelPubSub(channelUUID, pubSub)
127 | return channel, channelUUID, nil
128 | }
129 |
130 | func (r *Redis) ChannelMessage(message *Message) (string, error) {
131 | channelUUID, err := r.getChannelUUID(message.SenderUUID, message.RecipientUUID)
132 | if err != nil {
133 | return "", err
134 | }
135 |
136 | buff := bytes.NewBufferString("")
137 | enc := json.NewEncoder(buff)
138 | err = enc.Encode(message)
139 | if err != nil {
140 | return "", err
141 | }
142 |
143 | err = r.client.Publish(channelUUID, buff.String()).Err()
144 | if err != nil {
145 | return "", err
146 | }
147 | key := r.getKeyChannelMessages(channelUUID)
148 | err = r.client.RPush(key, buff.String()).Err()
149 | if err != nil {
150 | return "", err
151 | }
152 | return channelUUID, nil
153 | }
154 |
155 | func (r *Redis) ChannelLeave(senderUUID, recipientUUID string) (string, error) {
156 |
157 | channelUUID, err := r.getChannelUUID(senderUUID, recipientUUID)
158 | if err != nil {
159 | return "", err
160 | }
161 |
162 | defer func() {
163 | r.channelsPubSubSync.Lock()
164 | delete(r.channelsPubSub, channelUUID)
165 | r.channelsPubSubSync.Unlock()
166 | }()
167 |
168 | r.channelsPubSubSync.RLock()
169 | channel, ok := r.channelsPubSub[channelUUID]
170 | r.channelsPubSubSync.RUnlock()
171 |
172 | if !ok {
173 | return "", errors.New("channel not found")
174 | }
175 |
176 | close(channel.close)
177 |
178 | timeout := time.NewTimer(time.Second * 3)
179 | select {
180 | case <-channel.closed:
181 | return channelUUID, nil
182 | case <-timeout.C:
183 | return "", errors.New("channel closed with timeout")
184 | }
185 |
186 | }
187 |
188 | func (r *Redis) ChannelMessagesCount(channelUUID string) (int64, error) {
189 | key := r.getKeyChannelMessages(channelUUID)
190 | return r.client.LLen(key).Result()
191 | }
192 |
193 | func (r *Redis) ChannelMessages(channelUUID string, offset, limit int64) ([]*Message, error) {
194 |
195 | key := r.getKeyChannelMessages(channelUUID)
196 |
197 | log.Println("ChannelMessages", key, offset, limit)
198 |
199 | values, err := r.client.LRange(key, offset, limit).Result()
200 | if err != nil {
201 | return nil, err
202 | }
203 |
204 | messages := make([]*Message, 0, len(values))
205 | for i := range values {
206 | message := &Message{}
207 | dec := json.NewDecoder(strings.NewReader(values[i]))
208 | err := dec.Decode(message)
209 | if err != nil {
210 | return nil, err
211 | }
212 | if message.SenderUUID != "" {
213 | user, err := r.getUserFromListByUUID(message.SenderUUID)
214 | if err == nil {
215 | message.Sender = &User{
216 | UUID: user.UUID,
217 | Username: user.Username,
218 | }
219 | }
220 | }
221 | if message.RecipientUUID != "" {
222 | user, err := r.getUserFromListByUUID(message.RecipientUUID)
223 | if err == nil {
224 | message.Recipient = &User{
225 | UUID: user.UUID,
226 | Username: user.Username,
227 | }
228 | }
229 | }
230 | messages = append(messages, message)
231 | }
232 |
233 | return messages, nil
234 |
235 | }
236 |
237 | func (r *Redis) ChannelUsers(channelUUID string) ([]*User, error) {
238 |
239 | key := r.getKeyChannelUsers(channelUUID)
240 |
241 | values, err := r.client.HGetAll(key).Result()
242 | if err != nil {
243 | return nil, err
244 | }
245 |
246 | users := make([]*User, 0)
247 |
248 | for userUUID, _ := range values {
249 | user, err := r.getUserFromListByUUID(userUUID)
250 | if err != nil {
251 | log.Println(err)
252 | continue
253 | }
254 | users = append(users, user)
255 | }
256 |
257 | return users, nil
258 |
259 | }
260 |
261 | /*
262 | func (r *Redis) ChannelUsersUUID(channelUUID string) ([]string, error) {
263 |
264 | keyChannelUsers := r.keyChannelUsers(channelUUID)
265 | n, err := r.client.LLen(keyChannelUsers).Result()
266 | if err != nil {
267 | return nil, err
268 | }
269 | return r.client.LRange(keyChannelUsers, 0, n).Result()
270 | }
271 | */
272 | /*
273 | func redisChannelMessage(senderUUID, recipientUUID, textMessage string) error {
274 | keyChannelMessage := redisKeyChannelMessage(senderUUID, recipientUUID)
275 | message := Message{
276 | UUID: uuid.NewString(),
277 | SenderUUID: senderUUID,
278 | RecipientUUID: recipientUUID,
279 | Message: textMessage,
280 | CreatedAt: time.Now(),
281 | }
282 | data, err := json.Marshal(message)
283 | if err != nil {
284 | return fmt.Errorf("could not marshal json: %w", err)
285 | }
286 | err = r.HSet(keyChannelMessage, message.UUID, string(data)).Err()
287 | if err != nil {
288 | return fmt.Errorf("could not HSET data: %w", err)
289 | }
290 | return nil
291 | }
292 |
293 | func redisChannelMessages(senderUUID, recipientUUID string) ([]Message, error) {
294 | keyChannelMessage := redisKeyChannelMessage(senderUUID, recipientUUID)
295 | values, err := r.HGetAll(keyChannelMessage).Result()
296 | if err != nil {
297 | return nil, err
298 | }
299 | messages := make([]Message, 0, len(values))
300 | for i := range values {
301 | message := Message{}
302 | err := json.Unmarshal([]byte(values[i]), &message)
303 | if err != nil {
304 | return nil, err
305 | }
306 | messages = append(messages, message)
307 | }
308 | return messages, nil
309 | }
310 |
311 | func redisChannelUsers(senderUUID, recipientUUID string) ([]User, error) {
312 | key := redisKeyChannelUsers(senderUUID, recipientUUID)
313 | log.Println("redisChannelUsers:", key)
314 | values, err := r.HGetAll(key).Result()
315 | if err != nil {
316 | return nil, fmt.Errorf("could not GHETALL: %w", err)
317 | }
318 |
319 | log.Println("values:", fmt.Sprintf("%+v", values))
320 |
321 | users := make([]User, 0, len(values))
322 | for i := range values {
323 | user := User{}
324 | err := json.Unmarshal([]byte(values[i]), &user)
325 | if err != nil {
326 | return nil, fmt.Errorf("could not unmarshal [%+v] : %w", values[i], err)
327 | }
328 | users = append(users, user)
329 | }
330 |
331 | return users, nil
332 | }
333 | */
334 |
--------------------------------------------------------------------------------
/rediscli/channel_test.go:
--------------------------------------------------------------------------------
1 | package rediscli
2 |
3 | import (
4 | "fmt"
5 | "github.com/google/uuid"
6 | "log"
7 | "sync"
8 | "testing"
9 | "time"
10 | )
11 |
12 | func TestRedis_ChannelJoinPrivate(t *testing.T) {
13 |
14 | senderUUID := "TEST_SENDER"
15 | recipientUUID := "TEST_RECIPIENT"
16 |
17 | chMessageX, _, err := testRedisInstance.ChannelJoin(senderUUID, recipientUUID)
18 | if err != nil {
19 | log.Fatal(err)
20 | }
21 |
22 | chMessageY, _, err := testRedisInstance.ChannelJoin(recipientUUID, senderUUID)
23 | if err != nil {
24 | log.Fatal(err)
25 | }
26 |
27 | channelUUIDX, err := testRedisInstance.getChannelUUID(senderUUID, recipientUUID)
28 | if err != nil {
29 | log.Fatal(err)
30 | }
31 |
32 | channelUUIDY, err := testRedisInstance.getChannelUUID(recipientUUID, senderUUID)
33 | if err != nil {
34 | log.Fatal(err)
35 | }
36 |
37 | if channelUUIDX != channelUUIDY {
38 | t.Fatalf("expected channelX [%s] equal channelY [%s]", channelUUIDX, channelUUIDY)
39 | }
40 |
41 | wg := sync.WaitGroup{}
42 | wg.Add(3)
43 |
44 | go func() {
45 | defer wg.Done()
46 | for i := 0; i < 5; i++ {
47 | time.Sleep(time.Millisecond * 100)
48 | message := &Message{
49 | UUID: uuid.NewString(), //fmt.Sprintf("%s%d", id, i+1),
50 | SenderUUID: senderUUID,
51 | RecipientUUID: recipientUUID,
52 | Message: fmt.Sprintf("Helo %s #%d", recipientUUID, i+1),
53 | CreatedAt: time.Now(),
54 | }
55 | _,err := testRedisInstance.ChannelMessage(message)
56 | if err != nil {
57 | t.Error(err)
58 | }
59 | }
60 | }()
61 |
62 | go func() {
63 | defer wg.Done()
64 |
65 | for i := 0; i < 5; i++ {
66 | data := <-chMessageX.Channel()
67 | log.Println(fmt.Sprintf("X >>> %+v", data))
68 | }
69 |
70 | }()
71 |
72 | go func() {
73 | defer wg.Done()
74 |
75 | for i := 0; i < 5; i++ {
76 | data := <-chMessageY.Channel()
77 | log.Println(fmt.Sprintf("Y >>> %+v", data))
78 | }
79 |
80 | }()
81 |
82 | wg.Wait()
83 |
84 | }
85 |
86 | func TestRedis_ChannelJoinPublic(t *testing.T) {
87 |
88 | senderUUID := "TEST_SENDER"
89 | recipientUUID := ""
90 |
91 | chMessage, _, err := testRedisInstance.ChannelJoin(senderUUID, recipientUUID)
92 | if err != nil {
93 | log.Fatal(err)
94 | }
95 |
96 | _, err = testRedisInstance.getChannelUUID(senderUUID, recipientUUID)
97 | if err != nil {
98 | log.Fatal(err)
99 | }
100 |
101 | wg := sync.WaitGroup{}
102 | wg.Add(2)
103 |
104 | go func() {
105 | defer wg.Done()
106 | for i := 0; i < 5; i++ {
107 | time.Sleep(time.Millisecond * 100)
108 | message := &Message{
109 | UUID: uuid.NewString(), //fmt.Sprintf("%s%d", id, i+1),
110 | SenderUUID: senderUUID,
111 | RecipientUUID: recipientUUID,
112 | Message: fmt.Sprintf("Helo %s #%d", recipientUUID, i+1),
113 | CreatedAt: time.Now(),
114 | }
115 | _,err := testRedisInstance.ChannelMessage(message)
116 | if err != nil {
117 | t.Error(err)
118 | }
119 | }
120 | }()
121 |
122 | go func() {
123 | defer wg.Done()
124 |
125 | for i := 0; i < 5; i++ {
126 | data := <-chMessage.Channel()
127 | log.Println(fmt.Sprintf("X >>> %+v", data))
128 | }
129 |
130 | }()
131 |
132 | wg.Wait()
133 |
134 | }
135 |
--------------------------------------------------------------------------------
/rediscli/connection.go:
--------------------------------------------------------------------------------
1 | package rediscli
2 |
3 | import (
4 | "fmt"
5 | "time"
6 | )
7 |
8 | const (
9 | keyUserSession = "userSession"
10 | )
11 | func (r *Redis) getKeyUserSession(userSessionUUID string) string {
12 | return fmt.Sprintf("%s.%s", keyUserSession, userSessionUUID)
13 | }
14 |
15 | func (r *Redis) AddConnection(userSessionUUID string) error {
16 | key := r.getKeyUserSession(userSessionUUID)
17 | return r.client.Set(key, time.Now().String(), time.Hour).Err()
18 | }
19 |
20 | func (r *Redis) DelConnection(userSessionUUID string) error {
21 | key := r.getKeyUserSession(userSessionUUID)
22 | return r.client.Del(key).Err()
23 | }
24 |
--------------------------------------------------------------------------------
/rediscli/redis.go:
--------------------------------------------------------------------------------
1 | package rediscli
2 |
3 | import (
4 | "github.com/go-redis/redis"
5 | "log"
6 | "sync"
7 | )
8 |
9 | type Redis struct {
10 | client *redis.Client
11 | channelsPubSub map[string]*ChannelPubSub
12 | channelsPubSubSync *sync.RWMutex
13 | }
14 |
15 | type ChannelPubSub struct {
16 | close chan struct{}
17 | closed chan struct{}
18 | pubSub *redis.PubSub
19 | }
20 |
21 | func (channel *ChannelPubSub) Channel() <-chan *redis.Message {
22 | return channel.pubSub.Channel()
23 | }
24 |
25 | func (channel *ChannelPubSub) Close() <-chan struct{} {
26 | return channel.close
27 | }
28 |
29 | func (channel *ChannelPubSub) Closed() <-chan struct{} {
30 | return channel.closed
31 | }
32 |
33 | func NewRedis(addr, passwd string) *Redis {
34 |
35 | log.Println("Initialized redis client", addr,passwd)
36 |
37 | opt := &redis.Options{
38 | Addr: addr,
39 | }
40 |
41 | if passwd != "" {
42 | opt.Password = passwd
43 | }
44 |
45 | c := redis.NewClient(opt)
46 | if err := c.Ping().Err(); err != nil {
47 | panic(err)
48 | }
49 |
50 | r := &Redis{
51 | client: c,
52 | channelsPubSub: make(map[string]*ChannelPubSub, 0),
53 | channelsPubSubSync: &sync.RWMutex{},
54 | }
55 | return r
56 | }
57 |
--------------------------------------------------------------------------------
/rediscli/user.go:
--------------------------------------------------------------------------------
1 | package rediscli
2 |
3 | import (
4 | "bytes"
5 | "crypto/md5"
6 | "encoding/json"
7 | "errors"
8 | "fmt"
9 | "github.com/go-redis/redis"
10 | "github.com/google/uuid"
11 | "log"
12 | "strconv"
13 | "strings"
14 | "time"
15 | )
16 |
17 | const (
18 | keyUsers = "users"
19 | keyUserStatus = "userStatus"
20 | keyUserChannels = "userChannels"
21 | keyUserAccessKey = "userAccessKey"
22 | keyUsersUUIDListIndex = "usersUUIDListIndex"
23 | keyUsersUsernameListIndex = "usersUsernameListIndex"
24 | )
25 |
26 | type User struct {
27 | UUID string `json:"UUID"`
28 | Username string `json:"Username"`
29 | Password string `json:"Password,omitempty"`
30 | AccessKey string `json:"AccessKey,omitempty"`
31 | OnLine bool `json:"OnLine"`
32 | SessionUUID string `json:"-"`
33 | }
34 |
35 | func (r *Redis) getKeyUsers() string {
36 | return keyUsers
37 | }
38 |
39 | func (r *Redis) getKeyUsersUUIDListIndex(userUUID string) string {
40 | return fmt.Sprintf("%s.%s", keyUsersUUIDListIndex, userUUID)
41 | }
42 |
43 | func (r *Redis) getKeyUsersUsernameListIndex(username string) string {
44 | return fmt.Sprintf("%s.%x", keyUsersUsernameListIndex, md5.Sum([]byte(username)))
45 | }
46 |
47 | func (r *Redis) getUserIndexByUsername(username string) (int64, error) {
48 |
49 | log.Println("getUserIndexByUsername", username)
50 |
51 | key := r.getKeyUsersUsernameListIndex(username)
52 | value, err := r.client.Get(key).Result()
53 | if err != nil {
54 | return 0, err
55 | }
56 | index, err := strconv.ParseInt(value, 10, 64)
57 | if err != nil {
58 | return 0, err
59 | }
60 | return index, nil
61 | }
62 |
63 | func (r *Redis) getUserIndexByUUID(userUUID string) (int64, error) {
64 |
65 | log.Println("getUserIndexByUUID", userUUID)
66 |
67 | key := r.getKeyUsersUUIDListIndex(userUUID)
68 | value, err := r.client.Get(key).Result()
69 | if err != nil {
70 | return 0, fmt.Errorf("getUserIndexByUUID: %w", err)
71 | }
72 | index, err := strconv.ParseInt(value, 10, 64)
73 | if err != nil {
74 | return 0, fmt.Errorf("getUserIndexByUUID: %w", err)
75 | }
76 | return index, nil
77 | }
78 |
79 | func (r *Redis) getKeyUserStatus(userUUID string) string {
80 | return fmt.Sprintf("%s.%s", keyUserStatus, userUUID)
81 | }
82 |
83 | func (r *Redis) getKeyUserChannels(userUUID string) string {
84 | return fmt.Sprintf("%s.%s", keyUserChannels, userUUID)
85 | }
86 |
87 | func (r *Redis) getKeyUserAccessKey(userUUID string) string {
88 | return fmt.Sprintf("%s.%s", keyUserAccessKey, userUUID)
89 | }
90 |
91 | func (r *Redis) UserAuthorize(username, password string) (*User, error) {
92 |
93 | log.Println("UserAuthorize", fmt.Sprintf("[%s|%s]", username, password))
94 |
95 | user, err := r.UserGet(username)
96 | if errors.Is(err, redis.Nil) {
97 | user, err = r.UserCreate(username, password)
98 | if err != nil {
99 | return nil, err
100 | }
101 | } else if err != nil {
102 | return nil, err
103 | }
104 |
105 | log.Println("UserAuthorize", fmt.Sprintf("%+v", user))
106 |
107 | if user.Password != password {
108 | return nil, errors.New("wrong password")
109 | }
110 |
111 | user.AccessKey, err = r.UserUpdateAccessKey(user.UUID)
112 | if err != nil {
113 | return nil, err
114 | }
115 |
116 | err = r.UserSetOnline(user.UUID)
117 | if err != nil {
118 | return nil, err
119 | }
120 |
121 | return user, nil
122 |
123 | }
124 |
125 | func (r *Redis) addUser(user *User) error {
126 | buff := bytes.NewBufferString("")
127 | enc := json.NewEncoder(buff)
128 | err := enc.Encode(user)
129 | if err != nil {
130 | return err
131 | }
132 |
133 | key := r.getKeyUsers()
134 |
135 | elements, err := r.client.RPush(key, buff.String()).Result()
136 | if err != nil {
137 | return nil
138 | }
139 |
140 | index := elements - 1
141 | keyUserUsernameIndex := r.getKeyUsersUsernameListIndex(user.Username)
142 | keyUserUUIDIndex := r.getKeyUsersUUIDListIndex(user.UUID)
143 |
144 | err = r.client.Set(keyUserUsernameIndex, fmt.Sprintf("%d", index), 0).Err()
145 | if err != nil {
146 | return err
147 | }
148 |
149 | err = r.client.Set(keyUserUUIDIndex, fmt.Sprintf("%d", index), 0).Err()
150 | if err != nil {
151 | r.client.Del(keyUserUsernameIndex)
152 | return err
153 | }
154 |
155 | return nil
156 | }
157 |
158 | func (r *Redis) getUserFromList(userIndex int64) (*User, error) {
159 |
160 | key := r.getKeyUsers()
161 |
162 | value, err := r.client.LIndex(key, userIndex).Result()
163 | if err != nil {
164 | return nil, fmt.Errorf("getUserFromList[%d]: %w", userIndex, err)
165 | }
166 |
167 | user := &User{}
168 |
169 | dec := json.NewDecoder(strings.NewReader(value))
170 | err = dec.Decode(user)
171 | if err != nil {
172 | return nil, fmt.Errorf("getUserFromList[%d]: %w", userIndex, err)
173 | }
174 |
175 | return user, nil
176 | }
177 |
178 | func (r *Redis) getUserFromListByUsername(username string) (*User, error) {
179 |
180 | log.Println("getUserFromListByUsername", username)
181 |
182 | userIndex, err := r.getUserIndexByUsername(username)
183 | if err != nil {
184 | return nil, err
185 | }
186 |
187 | user, err := r.getUserFromList(userIndex)
188 | if err != nil {
189 | return nil, err
190 | }
191 |
192 | user.OnLine = r.UserIsOnline(user.UUID)
193 |
194 | return user, nil
195 |
196 | }
197 |
198 | func (r *Redis) getUserFromListByUUID(userUUID string) (*User, error) {
199 |
200 | log.Println("getUserFromListByUUID", userUUID)
201 |
202 | userIndex, err := r.getUserIndexByUUID(userUUID)
203 | if err != nil {
204 | return nil, fmt.Errorf("getUserFromListByUUID[%s]: %w", userUUID, err)
205 | }
206 |
207 | user, err := r.getUserFromList(userIndex)
208 | if err != nil {
209 | return nil, fmt.Errorf("getUserFromListByUUID[%s]: %w", userUUID, err)
210 | }
211 |
212 | user.OnLine = r.UserIsOnline(user.UUID)
213 |
214 | return user, nil
215 |
216 | }
217 |
218 | func (r *Redis) UserCreate(username, password string) (*User, error) {
219 |
220 | log.Println("UserCreate", fmt.Sprintf("[%s|%s]", username, password))
221 |
222 | if user, err := r.getUserFromListByUsername(username); err == nil {
223 | return user, nil
224 | }
225 |
226 | user := &User{
227 | UUID: uuid.NewString(),
228 | Username: username,
229 | Password: password,
230 | }
231 |
232 | if err := r.addUser(user); err != nil {
233 | return nil, err
234 | }
235 |
236 | return user, nil
237 |
238 | }
239 |
240 | func (r *Redis) UserGet(userUUID string) (*User, error) {
241 | log.Println("UserGet", userUUID)
242 | user, err := r.getUserFromListByUUID(userUUID)
243 | if err != nil {
244 | return nil, fmt.Errorf("UserGET[%s]: %w", userUUID, err)
245 | }
246 | return user, nil
247 | }
248 |
249 | func (r *Redis) UserAll() ([]*User, error) {
250 |
251 | key := r.getKeyUsers()
252 |
253 | items, err := r.client.LLen(key).Result()
254 | if err != nil {
255 | return nil, err
256 | }
257 |
258 | values, err := r.client.LRange(key, 0, items).Result()
259 |
260 | users := make([]*User, 0, items)
261 |
262 | for i := range values {
263 | user := &User{}
264 | dec := json.NewDecoder(strings.NewReader(values[i]))
265 | err = dec.Decode(user)
266 | if err != nil {
267 | return nil, fmt.Errorf("[%s]: %w", values[i], err)
268 | }
269 | users = append(users, user)
270 | }
271 |
272 | return users, nil
273 |
274 | }
275 |
276 | func (r *Redis) UserDeleteAccessKey(userUUID string) {
277 | key := r.getKeyUserAccessKey(userUUID)
278 | _ = r.client.Del(key)
279 | }
280 |
281 | func (r *Redis) UserUpdateAccessKey(userUUID string) (string, error) {
282 | key := r.getKeyUserAccessKey(userUUID)
283 | accessKey := uuid.New().String()
284 |
285 | err := r.client.Set(key, accessKey, 0).Err()
286 | if err != nil {
287 | return "", err
288 | }
289 | return accessKey, nil
290 | }
291 |
292 | func (r *Redis) UserSetOnline(userUUID string) error {
293 | key := r.getKeyUserStatus(userUUID)
294 | return r.client.Set(key, time.Now().String(), time.Minute).Err()
295 | }
296 |
297 | func (r *Redis) UserSetOffline(userUUID string) {
298 | key := r.getKeyUserStatus(userUUID)
299 | r.client.Del(key)
300 | }
301 |
302 | func (r *Redis) UserIsOnline(userUUID string) bool {
303 | key := r.getKeyUserStatus(userUUID)
304 | err := r.client.Get(key).Err()
305 | if err == nil {
306 | return true
307 | }
308 | return false
309 | }
310 |
311 | func (r *Redis) UserSignOut(userUUID string) {
312 | keyAccessKey := r.getKeyUserAccessKey(userUUID)
313 | r.UserDeleteAccessKey(keyAccessKey)
314 | r.UserSetOffline(userUUID)
315 | }
316 |
--------------------------------------------------------------------------------
/rediscli/user_test.go:
--------------------------------------------------------------------------------
1 | package rediscli
2 |
3 | import (
4 | "fmt"
5 | "log"
6 | "testing"
7 | )
8 |
9 | var testRedisInstance = NewRedis("localhost:44444", "")
10 | /*
11 | func TestRedis_UserStatus(t *testing.T) {
12 |
13 | testCases := []struct {
14 | userUUID string
15 | status UserStatus
16 | expected UserStatus
17 | }{
18 | {
19 | userUUID: "test user set status online",
20 | status: UserStatusOnline,
21 | expected: UserStatusOnline,
22 | }, {
23 | userUUID: "test user set status offline",
24 | status: UserStatusOffline,
25 | expected: UserStatusOffline,
26 | },
27 | }
28 |
29 | for i := range testCases {
30 |
31 | key := testRedisInstance.keyUsersStatus()
32 |
33 | err := testRedisInstance.UserSetStatus(testCases[i].userUUID, testCases[i].status)
34 | if err != nil {
35 | t.Fatal(err)
36 | }
37 |
38 | value, err := testRedisInstance.client.HGet(key, testCases[i].userUUID).Result()
39 | if err != nil {
40 | t.Fatal(err)
41 | }
42 |
43 | if value != string(testCases[i].expected) {
44 | t.Fatalf("expected [%s], actual [%s]", testCases[i].expected, value)
45 | }
46 |
47 | }
48 |
49 | }/*
50 |
51 | func TestUserMap(t *testing.T) {
52 |
53 | user := &User{
54 | UUID: "test user map",
55 | Username: "test user map",
56 | }
57 |
58 | if _, err := testRedisInstance.userMapGet("not exist user"); err != redis.Nil {
59 | t.Fatalf("expected error [%s], actual [%s]", redis.Nil, err)
60 | }
61 |
62 | err := testRedisInstance.userMapSet(user)
63 | if err != nil {
64 | t.Fatal(err)
65 | }
66 |
67 | userUUID, err := testRedisInstance.userMapGet(user.Username)
68 | if err != nil {
69 | t.Fatal(err)
70 | }
71 | if userUUID != user.UUID {
72 | t.Fatalf("expected user uuid [%s], actual [%s]", user.UUID, userUUID)
73 | }
74 | }*/
75 |
76 | func TestUserCreate(t *testing.T) {
77 |
78 | username := "test user"
79 | password := "test password"
80 |
81 | user, err := testRedisInstance.UserCreate(username, password)
82 | if err != nil {
83 | t.Fatal("userCreate", err)
84 | }
85 |
86 | user, err = testRedisInstance.UserGet(user.UUID)
87 | if err != nil {
88 | t.Fatal("userGet", err)
89 | }
90 |
91 | if user.Username != username {
92 | log.Fatalf("expecte username [%s], actual username [%s]", username, user.Username)
93 | }
94 |
95 | users, err := testRedisInstance.UserAll()
96 | if err != nil {
97 | log.Fatalln("usersAll", err)
98 | }
99 |
100 | for i := range users {
101 | log.Println(fmt.Sprintf("%+v", users[i]))
102 | }
103 |
104 | }
105 |
--------------------------------------------------------------------------------
/websocket/README.md:
--------------------------------------------------------------------------------
1 | ## Into
2 | Backend application base on websocket
3 |
4 | All communications between client and server processed with websocket
5 |
6 | Data storage made on redis
7 | ## Open WS
8 | `const ws = WebSocket('ws://localhost:8080/ws')`
9 | ## WebSocket Events
10 | ##### Produced on websocket open
11 | `ws.onopen = function(event){};`
12 | ##### Produced on websocket closed
13 | `ws.onclose = function(event){};`
14 | ##### Produced on websocket catch error
15 | `ws.onerror = function(event){};`
16 | ##### Produced on websocket received message from server
17 | `ws.onmessage = function(event){};`
18 | ## Send message
19 | #### Write a message to websocket
20 | `ws.send(JSON.stringify(body))`
21 |
22 | The `body` must be `JSON Object`, websocket server expected message as `JSON Object` as `string`
23 |
24 | ## Accept messages from websocket
25 | `ws.onmessage = function(event){const body = JSON.parse(event.data);};`
26 |
27 | The `body` contained `Stringified JSON Object`
28 |
29 | ## Kind of messages
30 | ### Ready
31 | #### Client connected and ready to send/receive messages
32 | > ***Response***
33 | ```
34 | {
35 | "type": "ready",
36 | "ready": {
37 | "sessionUUID": "Session UUID"
38 | }
39 | }
40 | ```
41 | ### Error
42 | #### Server error response
43 | > ***Response***
44 | ```
45 | {
46 | "type": "error",
47 | "error": {
48 | "code":1,
49 | "message": "Error message"
50 | }
51 | }
52 | ```
53 | The server reply error response if request could not be processed, all kinds of messages will return error response with different `error.code` and `error.message`
54 |
55 | This response useful for easy global error check and UI-render general error message
56 | ### User SignIn
57 | #### Make user login
58 | > ***Request***
59 | ```
60 | {
61 | "SUUID": "Session UUID",
62 | "type": "signIn",
63 | "signId": {
64 | "username": "User name",
65 | "password": "User password"
66 | }
67 | }
68 | ```
69 | > ***Response***
70 | ```
71 | {
72 | "type": "authorized":
73 | "authorized": {
74 | "userUUID": "user UUID,
75 | "accessKey": "User Access Key"
76 | }
77 | }
78 | ```
79 | User will be created if not exists
80 | ### User SignUp
81 | #### Create user account
82 | > ***Request***
83 | ```
84 | {
85 | "SUUID":"Session UUID",
86 | "type": "signUp",
87 | "signUp": {
88 | "username": "User name",
89 | "password": "User password"
90 | }
91 | }
92 | ```
93 | > ***Response***
94 | ```
95 | {
96 | "type": "authorized",
97 | "authorized": {
98 | "userUUID": 1,
99 | "accessKey": "User Access Key"
100 | }
101 | }
102 | ```
103 | ### User SignOut
104 | #### Make user logout
105 | > ***Request***
106 | ```
107 | {
108 | "SUUID": "Session UUID",
109 | "type": "signOut",
110 | "userUUID: "User UUID",
111 | "userAccessKey": "User Access Key"
112 | }
113 | ```
114 | >
115 | > ***Response***
116 | ```
117 | {
118 | "type": "unauthorized",
119 | "unauthorized": {
120 | "userUUID": "User UUID"
121 | }
122 | }
123 | ```
124 | ### Users List
125 | #### Read users list
126 | > ***Request***
127 | ```
128 | {
129 | "SUUID": "Session UUID",
130 | "type": "users",
131 | "userUUID: "User UUID",
132 | "userAccessKey": "User Access Key"
133 | }
134 | ```
135 | >
136 | > ***Response***
137 | ```
138 | {
139 | "type": "users",
140 | "users": {
141 | "total": 0,
142 | "received": 0,
143 | "users": [
144 | {
145 | "UUID": "User UUID",
146 | "Username": "Username",
147 | "Password": "Password",
148 | "OnLine": true
149 | }
150 | ]
151 | }
152 | }
153 | ```
154 | ### Join to channel
155 | #### Connect user to channel for read and write messages
156 | > ***Request***
157 | ```
158 | {
159 | "SUUID": "Session UUID",
160 | "userUUID": "User UUID",
161 | "userAccessKey": "User Access Key",
162 | "type": "channelJoin",
163 | "channelJoin": {
164 | "recipientUUID": "User UUID"
165 | }
166 | }
167 | ```
168 | > ***Response***
169 | ```
170 | {
171 | "type": "channelJoin",
172 | "channelJoin": {
173 | "messages": [
174 | {
175 | "UUID: "Message UUID",
176 | "senderUUID": "User UUID",
177 | "recipientUUID": "User UUID",
178 | "message": "text",
179 | "created_at": "time"
180 | }
181 | ],
182 | "users": [
183 | {
184 | "UUID": "User UUID",
185 | "username": "username"
186 | }
187 | ]
188 | }
189 | }
190 | ```
191 | When `recipientUUID` equal to `0` user will be joined to public channel
192 | ### Send message
193 | #### Write a message from user to public or private channel
194 | > ***Request***
195 | ```
196 | {
197 | "SUUID": "Session UUID",
198 | "userUUID": "User UUID",
199 | "userAccessKey": "User Access Key",
200 | "type": "channelMessage",
201 | "channelMessage": {
202 | "recipientUUID": "User UUID",
203 | "message": "Message text"
204 | }
205 | }
206 | ```
207 | > ***Response***
208 | ```
209 | {
210 | "type": "channelMessage",
211 | "channelMessage": {
212 | "UUID": "Message UUID"
213 | "senderUUID": "User UUID",
214 | "recipientUUID": "User UUID",
215 | "message": "Message text"
216 | }
217 | }
218 | ```
219 | When `recipientUUID` equal to `0` the message will be sent to public channel
220 | ### Read messages
221 | #### List a messages from public or private channel
222 | > ***Request***
223 | ```
224 | {
225 | "SUUID": "Session UUID",
226 | "userUUID": "User UUID",
227 | "userAccessKey": "User Access Key",
228 | "type": "channelMessages",
229 | "channelMessages": {
230 | "recipientUUID": "User UUID",
231 | "offset": 1,
232 | "limit": 1
233 | }
234 | }
235 | ```
236 | > ***Response***
237 | ```
238 | {
239 | "type": "channelRead",
240 | "channelMessages": {
241 | "messagesTotal": 1,
242 | "messagesReceived": 1,
243 | "messages": [
244 | {
245 | "senderUUID": "User UUID",
246 | "recipientUUID": "User UUID",
247 | "message": "Message text",
248 | "createdAt": "created time"
249 | }
250 | ]
251 | }
252 | }
253 | ```
254 | When `recipientUUID` equal to `0` the messages will be read from public channel
255 |
256 | The `channelMessages.limit` should be less that `100`, default if `10`
257 |
258 | The `channelMessages.offset` is the entries offset, default is `0`
259 |
260 | All messages ordered from new to older
261 | ### Leave channel
262 | #### Exit from a channel and stop to receive messages from it
263 | > ***Request***
264 | ```
265 | {
266 | "SUUID": "Session UUID",
267 | "userUUID": "User UUID",
268 | "userAccessKey": "User Access Key",
269 | "type": "channelLeave"
270 | "channelLeave": {
271 | "recipientUUID": "User UUID"
272 | }
273 | }
274 | ```
275 | > ***Response***
276 | ```
277 | {
278 | "type": "channelLeave",
279 | "channelLeave": {
280 | "recipientUUID": "User UUID"
281 | }
282 | }
283 | ```
284 | The `recipientUUID` could not be equal `0`, user can not leave public channel
285 |
--------------------------------------------------------------------------------
/websocket/connection.go:
--------------------------------------------------------------------------------
1 | package websocket
2 |
3 | import (
4 | "io"
5 | "net"
6 | "sync"
7 | )
8 |
9 | var connectionsSync sync.RWMutex
10 |
11 | type Connection struct {
12 | conn io.ReadWriter
13 | userSessionID string
14 | }
15 |
16 | var connections = map[string]Connection{}
17 |
18 | func connectionAdd(conn net.Conn, userSessionUUID string) {
19 | connectionsSync.Lock()
20 | connections[userSessionUUID] = Connection{
21 | userSessionID: userSessionUUID,
22 | conn: conn,
23 | }
24 | connectionsSync.Unlock()
25 | }
26 |
27 | func connectionDel(userSessionUUID string) {
28 | connectionsSync.Lock()
29 | delete(connections, userSessionUUID)
30 | connectionsSync.Unlock()
31 | }
32 |
--------------------------------------------------------------------------------
/websocket/error.go:
--------------------------------------------------------------------------------
1 | package websocket
2 |
3 | import "errors"
4 |
5 | type IError interface {
6 | Error() (uint32, error)
7 | }
8 |
9 | const (
10 | errCode uint32 = iota
11 | errCodeJSUnmarshal
12 | errCodeWSRead
13 | errCodeWSWrite
14 | errCodeSignIn
15 | errCodeSignUp
16 | errCodeSignOut
17 | errCodeRedisChannelMessage
18 | errCodeRedisChannelUsers
19 | errCodeRedisGetSessionUUID
20 | errCodeRedisGetUserByUUID
21 | errCodeRedisChannelJoin
22 | )
23 |
24 | var (
25 | errWSRead = errors.New("could not read websocket connection")
26 | errSignIn = errors.New("could not signIn")
27 | )
28 |
--------------------------------------------------------------------------------
/websocket/websocket.go:
--------------------------------------------------------------------------------
1 | package websocket
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 | "github.com/gobwas/ws"
7 | "github.com/gobwas/ws/wsutil"
8 | "github.com/google/uuid"
9 | "github.com/redis-developer/basic-redis-chat-demo-go/message"
10 | "github.com/redis-developer/basic-redis-chat-demo-go/rediscli"
11 | "io"
12 | "log"
13 | "net"
14 | "net/http"
15 | "strings"
16 | )
17 |
18 | func Write(conn io.ReadWriter, op ws.OpCode, message *message.Message) error {
19 |
20 | data, err := json.Marshal(message)
21 | if err != nil {
22 | log.Println(err)
23 | return nil
24 | }
25 | log.Println("write socket message:", string(data))
26 | err = wsutil.WriteServerMessage(conn, op, data)
27 | if err != nil {
28 | log.Println(err)
29 | return err
30 | }
31 |
32 | return nil
33 | }
34 |
35 | func NewConnection(conn net.Conn, r *rediscli.Redis, c *message.Controller, initErr chan error) {
36 | userSessionUUID := uuid.NewString()
37 |
38 | err := r.AddConnection(userSessionUUID)
39 | if err != nil {
40 | initErr <- err
41 | return
42 | }
43 |
44 | connectionAdd(conn, userSessionUUID)
45 | defer func() {
46 | conn.Close()
47 | err := r.DelConnection(userSessionUUID)
48 | if err != nil {
49 | log.Println(err)
50 | }
51 | connectionDel(userSessionUUID)
52 |
53 | }()
54 |
55 | err = Write(conn, ws.OpText, c.Ready(userSessionUUID))
56 | if err != nil {
57 | initErr <- err
58 | return
59 | }
60 |
61 | initErr <- nil
62 |
63 | for {
64 | msg := &message.Message{}
65 |
66 | if data, op, err := wsutil.ReadClientData(conn); err != nil {
67 | log.Println(err)
68 | return
69 | //response := makeError(errCodeWSRead, fmt.Errorf("%s: %w", errWSRead, err))
70 | //wsWrite(ch, conn, op, response)
71 | } else if err = json.Unmarshal(data, msg); err != nil {
72 | response := c.Error(errCodeJSUnmarshal, err, userSessionUUID, msg)
73 | err = Write(conn, op, response)
74 | } else {
75 |
76 | var receivedErr IError
77 |
78 | log.Println("Received message:", string(data))
79 | switch msg.Type {
80 | case message.DataTypeSignIn:
81 | receivedErr = c.SignIn(userSessionUUID, conn, op, Write, msg)
82 | case message.DataTypeSignUp:
83 | receivedErr = c.SignUp(userSessionUUID, conn, op, Write, msg)
84 | case message.DataTypeSignOut:
85 | receivedErr = c.SignOut(userSessionUUID, conn, op, Write, msg)
86 | case message.DataTypeUsers:
87 | receivedErr = c.Users(userSessionUUID, conn, op, Write)
88 | case message.DataTypeChannelJoin:
89 | channelPubSub := new(rediscli.ChannelPubSub)
90 | channelPubSub, receivedErr = c.ChannelJoin(userSessionUUID, conn, op, Write, msg)
91 | if channelPubSub != nil {
92 | go chatReceiver(conn, channelPubSub, r, c)
93 | }
94 | case message.DataTypeChannelMessage:
95 | receivedErr = c.ChannelMessage(userSessionUUID, conn, op, Write, msg)
96 | case message.DataTypeChannelLeave:
97 | receivedErr = c.ChannelLeave(userSessionUUID, Write, msg)
98 | default:
99 | err := Write(conn, op, c.Error(errCode, fmt.Errorf("unknow request data type: %s", msg.Type), msg.UserUUID, msg))
100 | if err != nil {
101 | log.Println(err)
102 | continue
103 | }
104 | }
105 |
106 | if receivedErr != nil {
107 | log.Println(receivedErr)
108 | code, err := receivedErr.Error()
109 | err = Write(conn, op, c.Error(code, err, userSessionUUID, string(data)))
110 | log.Println(receivedErr)
111 | }
112 | }
113 | }
114 | }
115 |
116 | func Handler(r *rediscli.Redis, c *message.Controller) http.HandlerFunc {
117 | return func(writer http.ResponseWriter, request *http.Request) {
118 | conn, _, _, err := ws.UpgradeHTTP(request, writer)
119 | if err != nil {
120 | log.Println(err)
121 | writer.WriteHeader(http.StatusInternalServerError)
122 | _,_ = fmt.Fprintf(writer, "%s", err)
123 | return
124 | }
125 | chInitErr := make(chan error, 1)
126 | go NewConnection(conn, r, c, chInitErr)
127 | if err = <- chInitErr; err != nil {
128 | log.Println(err)
129 | writer.WriteHeader(http.StatusInternalServerError)
130 | _,_ = fmt.Fprintf(writer, "%s", err)
131 | return
132 | }
133 | }
134 | }
135 |
136 | func chatReceiver(conn net.Conn, channel *rediscli.ChannelPubSub, r *rediscli.Redis, c *message.Controller) {
137 |
138 | defer channel.Closed()
139 | for {
140 | select {
141 | case data := <-channel.Channel():
142 | msg := &message.DataChannelMessage{}
143 | dec := json.NewDecoder(strings.NewReader(data.Payload))
144 | err := dec.Decode(msg)
145 | if err != nil {
146 | log.Println(err)
147 | } else {
148 |
149 | if msg.SenderUUID != "" {
150 | user, err := r.UserGet(msg.SenderUUID)
151 | if err == nil {
152 | msg.Sender = &rediscli.User{
153 | UUID: user.UUID,
154 | Username: user.Username,
155 | }
156 | }
157 | }
158 |
159 | if msg.RecipientUUID != "" {
160 | user, err := r.UserGet(msg.RecipientUUID)
161 | if err == nil {
162 | msg.Recipient = &rediscli.User{
163 | UUID: user.UUID,
164 | Username: user.Username,
165 | }
166 | }
167 | }
168 |
169 | err := Write(conn, ws.OpText, &message.Message{
170 | Type: message.DataTypeChannelMessage,
171 | ChannelMessage: msg,
172 | })
173 | if err != nil {
174 | log.Println(err)
175 | }
176 | }
177 | case <-channel.Close():
178 | log.Println("Close channel")
179 | return
180 | }
181 | }
182 |
183 | }
184 |
--------------------------------------------------------------------------------